FSharpPlus


SeqT<'monad, 't> Type

Table of contents

Applicative

Static members

Static member Description

x *> y

Full Usage: x *> y

Parameters:
    x : SeqT<^Monad, 'T>
    y : SeqT<^Monad, 'U>

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

Sequences two lists left-to-right, discarding the value of the first argument.

x : SeqT<^Monad, 'T>
y : SeqT<^Monad, 'U>
Returns: SeqT<^Monad, 'U>

x <* y

Full Usage: x <* y

Parameters:
    x : SeqT<^Monad, 'U>
    y : SeqT<^Monad, 'T>

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

Sequences two lists left-to-right, discarding the value of the second argument.

x : SeqT<^Monad, 'U>
y : SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'U>

Other module members

Union cases

Union case Description

SeqT IEnumerableM<'monad, 't>

Full Usage: SeqT IEnumerableM<'monad, 't>

Parameters:
Item : IEnumerableM<'monad, 't>

Static members

Static member Description

x <!> f

Full Usage: x <!> f

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

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

f <*> x

Full Usage: f <*> x

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

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

x <|> y

Full Usage: x <|> y

Parameters:
    x : SeqT<^Monad, 'T>
    y : SeqT<^Monad, 'T>

Returns: SeqT<^Monad, 'T>
Modifiers: inline
x : SeqT<^Monad, 'T>
y : SeqT<^Monad, 'T>
Returns: SeqT<^Monad, 'T>

x >>= f

Full Usage: x >>= f

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

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

SeqT.CallCC(f)

Full Usage: SeqT.CallCC(f)

Parameters:
    f : ('T -> SeqT<^MonadCont<'R>, 'U>) -> SeqT<^b, 'd>

Returns: SeqT<^MonadCont<'R>, 'T>
Modifiers: inline
f : ('T -> SeqT<^MonadCont<'R>, 'U>) -> SeqT<^b, 'd>
Returns: SeqT<^MonadCont<'R>, 'T>

SeqT.Catch(m, h)

Full Usage: SeqT.Catch(m, h)

Parameters:
    m : SeqT<^MonadError<'E1>, 'T>
    h : 'E1 -> SeqT<^MonadError<'E2>, 'T>

Returns: SeqT<^MonadError<'E2>, 'T>
Modifiers: inline
m : SeqT<^MonadError<'E1>, 'T>
h : 'E1 -> SeqT<^MonadError<'E2>, 'T>
Returns: SeqT<^MonadError<'E2>, 'T>

SeqT.Delay(body)

Full Usage: SeqT.Delay(body)

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

Returns: SeqT<'Monad, 'T>
Modifiers: inline
body : unit -> SeqT<'Monad, 'T>
Returns: SeqT<'Monad, 'T>

SeqT.Drop(source, count, arg3)

Full Usage: SeqT.Drop(source, count, arg3)

Parameters:
    source : SeqT<^Monad, 'T>
    count : int
    arg2 : Drop

Returns: SeqT<^Monad, 'T>
Modifiers: inline
source : SeqT<^Monad, 'T>
count : int
arg2 : Drop
Returns: SeqT<^Monad, 'T>

SeqT.Lift(m)

Full Usage: SeqT.Lift(m)

Parameters:
    m : ^Monad<'T>

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

SeqT.Lift2(f, x1, x2)

Full Usage: SeqT.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: 'U, ^Monad<bool>
f : 'T1 -> 'T2 -> 'U
x1 : SeqT<^Monad, 'T1>
x2 : SeqT<^Monad, 'T2>
Returns: SeqT<^Monad, 'U>

SeqT.Lift3(f, x1, x2, x3)

Full Usage: SeqT.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: '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>

SeqT.LiftAsync(x)

Full Usage: SeqT.LiftAsync(x)

Parameters:
Returns: SeqT<^MonadAsync, 'T>
Modifiers: inline
Type parameters: ^MonadAsync<'T>
x : Async<'T>
Returns: SeqT<^MonadAsync, 'T>

SeqT.Limit(source, count, arg3)

Full Usage: SeqT.Limit(source, count, arg3)

Parameters:
    source : SeqT<^Monad, 'T>
    count : int
    arg2 : Limit

Returns: SeqT<^Monad, 'T>
Modifiers: inline
source : SeqT<^Monad, 'T>
count : int
arg2 : Limit
Returns: SeqT<^Monad, 'T>

SeqT.Local(m, f)

Full Usage: SeqT.Local(m, f)

Parameters:
    m : SeqT<^MonadReader<'R2>, 'T>
    f : 'R1 -> 'R2

Returns: SeqT<^MonadReader<'R1>, 'T>
Modifiers: inline
m : SeqT<^MonadReader<'R2>, 'T>
f : 'R1 -> 'R2
Returns: SeqT<^MonadReader<'R1>, 'T>

SeqT.Map(x, f)

Full Usage: SeqT.Map(x, f)

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

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

SeqT.OfSeq(x)

Full Usage: SeqT.OfSeq(x)

Parameters:
    x : 'T seq

Returns: SeqT<^Monad, 'T>
Modifiers: inline
x : 'T seq
Returns: SeqT<^Monad, 'T>

SeqT.Put(x)

Full Usage: SeqT.Put(x)

Parameters:
    x : 'T

Returns: SeqT<^MonadState, 'S>
Modifiers: inline
x : 'T
Returns: SeqT<^MonadState, 'S>

SeqT.Return(x)

Full Usage: SeqT.Return(x)

Parameters:
    x : 'T

Returns: SeqT<^Monad, 'T>
Modifiers: inline
x : 'T
Returns: SeqT<^Monad, 'T>

SeqT.Skip(source, count, arg3)

Full Usage: SeqT.Skip(source, count, arg3)

Parameters:
    source : SeqT<^Monad, 'T>
    count : int
    arg2 : Skip

Returns: SeqT<^Monad, 'T>
Modifiers: inline
source : SeqT<^Monad, 'T>
count : int
arg2 : Skip
Returns: SeqT<^Monad, 'T>

SeqT.Take(source, count, arg3)

Full Usage: SeqT.Take(source, count, arg3)

Parameters:
    source : SeqT<^Monad, 'T>
    count : int
    arg2 : Take

Returns: SeqT<^Monad, 'T>
Modifiers: inline
source : SeqT<^Monad, 'T>
count : int
arg2 : Take
Returns: SeqT<^Monad, 'T>

SeqT.Throw(x)

Full Usage: SeqT.Throw(x)

Parameters:
    x : 'E

Returns: SeqT<^MonadError<'E>, 'T>
Modifiers: inline
x : 'E
Returns: SeqT<^MonadError<'E>, 'T>

SeqT.TryFinally(computation, f)

Full Usage: SeqT.TryFinally(computation, f)

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

Returns: SeqT<^Monad, 'T>
Modifiers: inline
computation : SeqT<^Monad, 'T>
f : unit -> unit
Returns: SeqT<^Monad, 'T>

SeqT.TryWith(source, f)

Full Usage: SeqT.TryWith(source, f)

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

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

SeqT.Using(resource, f)

Full Usage: SeqT.Using(resource, f)

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

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

SeqT.Zip(source1, source2)

Full Usage: SeqT.Zip(source1, source2)

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

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

SeqT.get_Ask ()

Full Usage: SeqT.get_Ask ()

Returns: SeqT<^MonadReader<'R>, 'R>
Modifiers: inline
Type parameters: 'R
Returns: SeqT<^MonadReader<'R>, 'R>

SeqT.get_Empty ()

Full Usage: SeqT.get_Empty ()

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

SeqT.get_Get ()

Full Usage: SeqT.get_Get ()

Returns: SeqT<^MonadState<'S>, 'S>
Modifiers: inline
Type parameters: 'S
Returns: SeqT<^MonadState<'S>, 'S>