FSharpPlus

SeqT Module

Namespace: FSharpPlus.Data
Assembly: FSharpPlus.dll
Parent Module: SeqT_V2

Types

Type Description

AppendState<'Monad, 'T>

CollectState<'T, 'U, 'Monad>

Map2State<'T1, 'T2, 'Monad>

MapState<'T, 'Monad>

SeqState<'Monad>, 'T>

TryFinallyState<'Monad, 'T>

TryWithState<'Monad, 'T>

Functions and values

Function or value Description

append source1 source2

Full Usage: append source1 source2

Parameters:
    source1 : SeqT<^Monad, 'T>
    source2 : SeqT<^Monad, 'T>

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: ^Monad<bool>, 'T
source1 : SeqT<^Monad, 'T>
source2 : SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'T>

apply f x1

Full Usage: apply f x1

Parameters:
    f : SeqT<^Monad, ('T -> 'U)>
    x1 : SeqT<^Monad, 'T>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T, 'U, ^Monad<bool>
f : SeqT<^Monad, ('T -> 'U)>
x1 : SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'U>

bindLift f source

Full Usage: bindLift f source

Parameters:
    f : 'T -> SeqT<^Monad, 'U>
    source : ^Monad<'T>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T, 'U, ^Monad<bool>, ^Monad<SeqT<'Monad<bool>, 'U>>, ^Monad<'T>

A combination of bind and lift operations.

f : 'T -> SeqT<^Monad, 'U>
source : ^Monad<'T>
Returns: SeqT<^Monad, 'U>

collect f source

Full Usage: collect f source

Parameters:
    f : 'T -> SeqT<^Monad, 'U>
    source : SeqT<^Monad, 'T>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T, 'U, ^Monad<bool>
f : 'T -> SeqT<^Monad, 'U>
source : SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'U>

delay f

Full Usage: delay f

Parameters:
    f : unit -> SeqT<'Monad, 'T>

Returns: SeqT<'Monad, 'T>
f : unit -> SeqT<'Monad, 'T>
Returns: SeqT<'Monad, 'T>

drop count source

Full Usage: drop count source

Parameters:
    count : int - The number of items to skip.
    source : SeqT<^Monad, 'T> - The input sequence.

Returns: SeqT<^Monad, 'T> The result sequence.
Modifiers: inline
Type parameters: ^Monad<bool>, 'T

Returns a sequence that skips at most N elements of the underlying sequence and then yields the remaining elements of the sequence.

count : int

The number of items to skip.

source : SeqT<^Monad, 'T>

The input sequence.

Returns: SeqT<^Monad, 'T>

The result sequence.

ArgumentNullException Thrown when count is negative.

empty

Full Usage: empty

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>
Returns: SeqT<^Monad, 'T>

filter f source

Full Usage: filter f source

Parameters:
    f : 'T -> bool
    source : SeqT<^Monad, 'T>

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>
f : 'T -> bool
source : SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'T>

hoist source

Full Usage: hoist source

Parameters:
    source : 'T seq

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>

Transforms a regular sequence into a SeqT, driven by the return type. An alias of `ofSeq`.

source : 'T seq
Returns: SeqT<^Monad, 'T>

iter f source

Full Usage: iter f source

Parameters:
    f : 'T -> unit
    source : SeqT<^Monad, 'T>

Returns: ^Monad
Modifiers: inline
Type parameters: 'T, ^Monad<bool>, ^Monad<unit>
f : 'T -> unit
source : SeqT<^Monad, 'T>
Returns: ^Monad

iterM f source

Full Usage: iterM f source

Parameters:
    f : 'T -> ^Monad
    source : SeqT<^Monad, 'T>

Returns: ^Monad
Modifiers: inline
Type parameters: 'T, ^Monad<unit>, ^Monad<bool>
f : 'T -> ^Monad
source : SeqT<^Monad, 'T>
Returns: ^Monad

iteri f source

Full Usage: iteri f source

Parameters:
    f : int -> 'T -> unit
    source : SeqT<^Monad, 'T>

Returns: ^Monad
Modifiers: inline
Type parameters: 'T, ^Monad<bool>, ^Monad<unit>
f : int -> 'T -> unit
source : SeqT<^Monad, 'T>
Returns: ^Monad

iteriM f source

Full Usage: iteriM f source

Parameters:
    f : int -> 'T -> ^Monad
    source : SeqT<^Monad, 'T>

Returns: ^Monad
Modifiers: inline
Type parameters: 'T, ^Monad<unit>, ^Monad<bool>
f : int -> 'T -> ^Monad
source : SeqT<^Monad, 'T>
Returns: ^Monad

lift source

Full Usage: lift source

Parameters:
    source : ^Monad<'T>

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: ^Monad<'T>, ^Monad<bool>, 'T

Lifts the source into the SeqT.

source : ^Monad<'T>
Returns: SeqT<^Monad, 'T>

lift2 f x1 x2

Full Usage: lift2 f x1 x2

Parameters:
    f : 'T1 -> 'T2 -> 'U
    x1 : SeqT<^Monad, 'T1>
    x2 : SeqT<^Monad, 'T2>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T1, 'T2, 'U, ^Monad<bool>
f : 'T1 -> 'T2 -> 'U
x1 : SeqT<^Monad, 'T1>
x2 : SeqT<^Monad, 'T2>
Returns: SeqT<^Monad, 'U>

lift3 f x1 x2 x3

Full Usage: lift3 f x1 x2 x3

Parameters:
    f : 'T1 -> 'T2 -> 'T3 -> 'U
    x1 : SeqT<^Monad, 'T1>
    x2 : SeqT<^Monad, 'T2>
    x3 : SeqT<^Monad, 'T3>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T1, 'T2, 'T3, 'U, ^Monad<bool>
f : 'T1 -> 'T2 -> 'T3 -> 'U
x1 : SeqT<^Monad, 'T1>
x2 : SeqT<^Monad, 'T2>
x3 : SeqT<^Monad, 'T3>
Returns: SeqT<^Monad, 'U>

map f source

Full Usage: map f source

Parameters:
    f : 'T -> 'U
    source : SeqT<^Monad, 'T>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T, 'U, ^Monad<bool>
f : 'T -> 'U
source : SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'U>

map2 f source1 source2

Full Usage: map2 f source1 source2

Parameters:
    f : 'T1 -> 'T2 -> 'U
    source1 : SeqT<^Monad, 'T1>
    source2 : SeqT<^Monad, 'T2>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T1, 'T2, 'U, ^Monad<bool>
f : 'T1 -> 'T2 -> 'U
source1 : SeqT<^Monad, 'T1>
source2 : SeqT<^Monad, 'T2>
Returns: SeqT<^Monad, 'U>

map2M f source1 source2

Full Usage: map2M f source1 source2

Parameters:
    f : 'T1 -> 'T2 -> ^Monad<'U>
    source1 : SeqT<^Monad, 'T1>
    source2 : SeqT<^Monad, 'T2>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T1, 'T2, ^Monad<'U>, ^Monad<bool>, 'U
f : 'T1 -> 'T2 -> ^Monad<'U>
source1 : SeqT<^Monad, 'T1>
source2 : SeqT<^Monad, 'T2>
Returns: SeqT<^Monad, 'U>

map3 f source1 source2 source3

Full Usage: map3 f source1 source2 source3

Parameters:
    f : 'T1 -> 'T2 -> 'T3 -> 'U
    source1 : SeqT<^Monad, 'T1>
    source2 : SeqT<^Monad, 'T2>
    source3 : SeqT<^Monad, 'T3>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T1, 'T2, 'T3, 'U, ^Monad<bool>
f : 'T1 -> 'T2 -> 'T3 -> 'U
source1 : SeqT<^Monad, 'T1>
source2 : SeqT<^Monad, 'T2>
source3 : SeqT<^Monad, 'T3>
Returns: SeqT<^Monad, 'U>

map3M f source1 source2 source3

Full Usage: map3M f source1 source2 source3

Parameters:
    f : 'T1 -> 'T2 -> 'T3 -> ^Monad<'U>
    source1 : SeqT<^Monad, 'T1>
    source2 : SeqT<^Monad, 'T2>
    source3 : SeqT<^Monad, 'T3>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T1, 'T2, 'T3, ^Monad<'U>, ^Monad<bool>, 'U
f : 'T1 -> 'T2 -> 'T3 -> ^Monad<'U>
source1 : SeqT<^Monad, 'T1>
source2 : SeqT<^Monad, 'T2>
source3 : SeqT<^Monad, 'T3>
Returns: SeqT<^Monad, 'U>

mapM f source

Full Usage: mapM f source

Parameters:
    f : 'T -> ^Monad<'U>
    source : SeqT<^Monad, 'T>

Returns: SeqT<^Monad, 'U>
Modifiers: inline
Type parameters: 'T, ^Monad<'U>, ^Monad<SeqT<'Monad<bool>, 'U>>, ^Monad<bool>, 'U

A transformation, which traverses the sequence with an action in the inner monad.

f : 'T -> ^Monad<'U>
source : SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'U>

ofIEnumerableM x

Full Usage: ofIEnumerableM x

Parameters:
Returns: SeqT<'Monad, 'T>

Creates a SeqT sequence from an IEnumerableM.

x : IEnumerableM<'Monad, 'T>
Returns: SeqT<'Monad, 'T>

ofSeq source

Full Usage: ofSeq source

Parameters:
    source : 'T seq

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>

Transforms a regular sequence into a SeqT, driven by the return type.

source : 'T seq
Returns: SeqT<^Monad, 'T>

run source

Full Usage: run source

Parameters:
    source : SeqT<^Monad, 'T>

Returns: ^Monad<'Tseq>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>, ^Monad<'T seq>, ^Monad<unit>
source : SeqT<^Monad, 'T>
Returns: ^Monad<'Tseq>

runAsArray source

Full Usage: runAsArray source

Parameters:
    source : SeqT<^Monad, 'T>

Returns: ^Monad<'T[]>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>, ^Monad<'T []>, ^Monad<unit>
source : SeqT<^Monad, 'T>
Returns: ^Monad<'T[]>

runAsList source

Full Usage: runAsList source

Parameters:
    source : SeqT<^Monad, 'T>

Returns: ^Monad<'Tlist>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>, ^Monad<'T list>, ^Monad<unit>
source : SeqT<^Monad, 'T>
Returns: ^Monad<'Tlist>

singleton v

Full Usage: singleton v

Parameters:
    v : 'T

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>
v : 'T
Returns: SeqT<^Monad, 'T>

skip count source

Full Usage: skip count source

Parameters:
    count : int - The number of items to skip.
    source : SeqT<^Monad, 'T> - The input sequence.

Returns: SeqT<^Monad, 'T> The result sequence.
Modifiers: inline
Type parameters: ^Monad<bool>, 'T

Returns a sequence that skips N elements of the underlying sequence and then yields the remaining elements of the sequence.

Throws InvalidOperationException if the count exceeds the number of elements in the sequence. SeqT.drop returns as many items as the sequence contains instead of throwing an exception.

count : int

The number of items to skip.

source : SeqT<^Monad, 'T>

The input sequence.

Returns: SeqT<^Monad, 'T>

The result sequence.

ArgumentNullException Thrown when count is negative.
InvalidOperationException Thrown when count exceeds the number of elements in the sequence.

take count source

Full Usage: take count source

Parameters:
    count : int - The number of items to take.
    source : SeqT<^Monad, 'T> - The input sequence.

Returns: SeqT<^Monad, 'T> The result sequence.
Modifiers: inline
Type parameters: ^Monad<bool>, 'T

Returns the first N elements of the sequence.

Throws InvalidOperationException if the count exceeds the number of elements in the sequence. SeqT.truncate returns as many items as the sequence contains instead of throwing an exception.

count : int

The number of items to take.

source : SeqT<^Monad, 'T>

The input sequence.

Returns: SeqT<^Monad, 'T>

The result sequence.

ArgumentNullException Thrown when count is negative.
InvalidOperationException Thrown when count exceeds the number of elements. in the sequence.

truncate count source

Full Usage: truncate count source

Parameters:
    count : int - The maximum number of items to enumerate.
    source : SeqT<^Monad, 'T> - The input sequence.

Returns: SeqT<^Monad, 'T> The result sequence.
Modifiers: inline
Type parameters: ^Monad<bool>, 'T

Returns a sequence that when enumerated returns at most N elements.

count : int

The maximum number of items to enumerate.

source : SeqT<^Monad, 'T>

The input sequence.

Returns: SeqT<^Monad, 'T>

The result sequence.

ArgumentNullException Thrown when count is negative.

tryFinally source compensation

Full Usage: tryFinally source compensation

Parameters:
    source : SeqT<^Monad, 'T>
    compensation : unit -> unit

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: ^Monad<bool>, 'T

Implements the 'TryFinally' functionality for the computation expression builder.

source : SeqT<^Monad, 'T>
compensation : unit -> unit
Returns: SeqT<^Monad, 'T>

tryWith source handler

Full Usage: tryWith source handler

Parameters:
    source : SeqT<^Monad, 'T>
    handler : exn -> SeqT<^Monad, 'T>

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: 'T, ^Monad<bool>, ^Monad<unit>

Implements the 'TryWith' functionality for the computation expression builder.

source : SeqT<^Monad, 'T>
handler : exn -> SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'T>

unfold f s

Full Usage: unfold f s

Parameters:
    f : 'State -> ('T * 'State) option
    s : 'State

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: 'State, 'T, ^Monad<bool>, ^Monad<('T * 'State) option>
f : 'State -> ('T * 'State) option
s : 'State
Returns: SeqT<^Monad, 'T>

unfoldM f s

Full Usage: unfoldM f s

Parameters:
    f : 'State -> ^Monad<('T*'State)option>
    s : 'State

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: 'State, ^Monad<('T * 'State) option>, ^Monad<bool>, 'T
f : 'State -> ^Monad<('T*'State)option>
s : 'State
Returns: SeqT<^Monad, 'T>

wrap source

Full Usage: wrap source

Parameters:
    source : ^Monad>

Returns: SeqT<^Monad, 'T>
Modifiers: inline
Type parameters: ^Monad<seq<'T>>, ^Monad<bool>, 'T
source : ^Monad>
Returns: SeqT<^Monad, 'T>

zip source1 source2

Full Usage: zip source1 source2

Parameters:
    source1 : SeqT<^Monad, 'T1>
    source2 : SeqT<^Monad, 'T2>

Returns: SeqT<^Monad, ('T1 * 'T2)>
Modifiers: inline
Type parameters: ^Monad<bool>, 'T1, 'T2
source1 : SeqT<^Monad, 'T1>
source2 : SeqT<^Monad, 'T2>
Returns: SeqT<^Monad, ('T1 * 'T2)>

zip3 source1 source2 source3

Full Usage: zip3 source1 source2 source3

Parameters:
    source1 : SeqT<^Monad, 'T1>
    source2 : SeqT<^Monad, 'T2>
    source3 : SeqT<^Monad, 'T3>

Returns: SeqT<^Monad, ('T1 * 'T2 * 'T3)>
Modifiers: inline
Type parameters: ^Monad<bool>, 'T1, 'T2, 'T3
source1 : SeqT<^Monad, 'T1>
source2 : SeqT<^Monad, 'T2>
source3 : SeqT<^Monad, 'T3>
Returns: SeqT<^Monad, ('T1 * 'T2 * 'T3)>