This is a wrapper over seq<'T> which changes its applicative semantic to point-wise processing.
open FSharpPlus
open FSharpPlus.Data
let seq1 = seq { 1..100000}
let seq2 = seq {10..100000}
let seq1_plus_seq2 = (+) <!> ZipList seq1 <*> ZipList seq2
open FSharpPlus.Math.Applicative
let seq1_plus_seq2' = ZipList seq1 .+. ZipList seq2
let arrCombined = 10 *. ZipList seq1 .+. ZipList seq2 .- 5
let asMonoid = result "Hello " </plus/> ZipList ["City"; "World"; "Sun"]
// try ZipList.run {the results}
namespace FSharpPlus
namespace FSharpPlus.Data
val seq1: int seq
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
val seq2: int seq
val seq1_plus_seq2: ZipList<int>
Multiple items
union case ZipList.ZipList: 's seq -> ZipList<'s>
--------------------
module ZipList
from FSharpPlus.Data
<summary>
Basic operations on ZipList
</summary>
--------------------
type ZipList<'s> =
| ZipList of 's seq
member Item: n: int -> 's
static member (+) : x: ZipList<'a> * y: ZipList<'a> -> ZipList<'a> (requires member ``+``)
static member (<*>) : ZipList<('a -> 'b)> * ZipList<'a> -> ZipList<'b>
static member (<|>) : ZipList<'a> * ZipList<'a> -> ZipList<'a>
static member Return: x: 'a -> ZipList<'a>
static member ToSeq: ZipList<'a> -> 'a seq
static member Traverse: ZipList<'T> * f: ('T -> 'Functor<'U>) -> 'Functor<ZipList<'U>> (requires member Map and member ``<*>`` and member IsLeftZero and member Map and member Map and member Traverse and member Return and member Map)
static member get_Empty: unit -> ZipList<'a>
static member Zero: unit -> ZipList<'a> (requires member Zero)
<summary>
A sequence with an Applicative functor based on zipping.
</summary>
namespace FSharpPlus.Math
module Applicative
from FSharpPlus.Math
<summary>Math Operators ready to use over Applicative Functors.</summary>
val seq1_plus_seq2': ZipList<int>
val arrCombined: ZipList<int>
val asMonoid: ZipList<string>
val result: x: 'T -> 'Functor<'T> (requires member Return)
<summary>
Lifts a value into a Functor. Same as return in Computation Expressions.
</summary>
<category index="2">Applicative</category>
val plus: x: 'Monoid -> y: 'Monoid -> 'Monoid (requires member ``+``)
<summary>
Combines two monoids in one.
</summary>
<category index="4">Monoid</category>