FSharpPlus


WriterT<'monad<'t * 'monoid>> Type

Monad Transformer for Writer<'Monoid, 'T>

Table of contents

Functor

Static members

Static member Description

f <!> x

Full Usage: f <!> x

Parameters:
    f : 'T -> 'U
    x : WriterT<^Monad<'T*'Monoid>>

Returns: WriterT<^Monad<'U*'Monoid>>
Modifiers: inline

Lifts a function into a WriterT. Same as map. To be used in Applicative Style expressions, combined with <*>

f : 'T -> 'U
x : WriterT<^Monad<'T*'Monoid>>
Returns: WriterT<^Monad<'U*'Monoid>>

Applicative

Static members

Static member Description

x *> y

Full Usage: x *> y

Parameters:
Returns: WriterT<^Monad<'U*'Monoid>>
Modifiers: inline

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

x : WriterT<^Monad<'T*'Monoid>>
y : WriterT<^Monad<'U*'Monoid>>
Returns: WriterT<^Monad<'U*'Monoid>>

x <* y

Full Usage: x <* y

Parameters:
Returns: WriterT<^Monad<'U*'Monoid>>
Modifiers: inline

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

x : WriterT<^Monad<'U*'Monoid>>
y : WriterT<^Monad<'T*'Monoid>>
Returns: WriterT<^Monad<'U*'Monoid>>

Monad

Static members

Static member Description

f >=> g

Full Usage: f >=> g

Parameters:
    f : 'T -> WriterT<^Monad<'U*'Monoid>>
    g : 'U -> WriterT<^Monad<'V*'Monoid>>

Returns: 'T -> WriterT<^Monad<'V*'Monoid>>
Modifiers: inline

Composes left-to-right two Writer functions (Kleisli composition).

f : 'T -> WriterT<^Monad<'U*'Monoid>>
g : 'U -> WriterT<^Monad<'V*'Monoid>>
Returns: 'T -> WriterT<^Monad<'V*'Monoid>>

Other module members

Union cases

Union case Description

WriterT 'monad<'t*'monoid>

Full Usage: WriterT 'monad<'t*'monoid>

Parameters:
    Item : 'monad<'t*'monoid>

Item : 'monad<'t*'monoid>

Static members

Static member Description

f <*> x

Full Usage: f <*> x

Parameters:
    f : WriterT<^Monad<('T->'U)*'Monoid>>
    x : WriterT<^Monad<'T*'Monoid>>

Returns: WriterT<^Monad<'U*'Monoid>>
Modifiers: inline
f : WriterT<^Monad<('T->'U)*'Monoid>>
x : WriterT<^Monad<'T*'Monoid>>
Returns: WriterT<^Monad<'U*'Monoid>>

arg0 <|> arg1

Full Usage: arg0 <|> arg1

Parameters:
    arg0 : WriterT<^MonadPlus<'T*'Monoid>>
    arg1 : WriterT<^MonadPlus<'T*'Monoid>>

Returns: WriterT<^MonadPlus<'T*'Monoid>>
Modifiers: inline
arg0 : WriterT<^MonadPlus<'T*'Monoid>>
arg1 : WriterT<^MonadPlus<'T*'Monoid>>
Returns: WriterT<^MonadPlus<'T*'Monoid>>

x >>= f

Full Usage: x >>= f

Parameters:
    x : WriterT<^Monad<'T*'Monoid>>
    f : 'T -> WriterT<^Monad<'U*'Monoid>>

Returns: WriterT<^Monad<'U*'Monoid>>
Modifiers: inline
x : WriterT<^Monad<'T*'Monoid>>
f : 'T -> WriterT<^Monad<'U*'Monoid>>
Returns: WriterT<^Monad<'U*'Monoid>>

WriterT.CallCC(f)

Full Usage: WriterT.CallCC(f)

Parameters:
Returns: WriterT<^MonadCont<'r,'a*'b>>
Modifiers: inline
f : ('a -> WriterT<Cont<'r, 't>>) -> WriterT<^MonadCont<'r,'a*'b>>
Returns: WriterT<^MonadCont<'r,'a*'b>>

WriterT.Catch(m, h)

Full Usage: WriterT.Catch(m, h)

Parameters:
    m : WriterT<^MonadError<'E1,'T*'Monoid>>
    h : 'E1 -> WriterT<^MonadError<'E2,'T*'Monoid>>

Returns: WriterT<^MonadError<'E2,'T*'Monoid>>
Modifiers: inline
Type parameters: ^MonadError<'E2, 'T * 'Monoid>, 'E1
m : WriterT<^MonadError<'E1,'T*'Monoid>>
h : 'E1 -> WriterT<^MonadError<'E2,'T*'Monoid>>
Returns: WriterT<^MonadError<'E2,'T*'Monoid>>

WriterT.Delay(body)

Full Usage: WriterT.Delay(body)

Parameters:
    body : unit -> WriterT<^Monad<'T*'Monoid>>

Returns: WriterT<^Monad<'T*'Monoid>>
Modifiers: inline
body : unit -> WriterT<^Monad<'T*'Monoid>>
Returns: WriterT<^Monad<'T*'Monoid>>

WriterT.Lift(m)

Full Usage: WriterT.Lift(m)

Parameters:
    m : ^Monad<'T>

Returns: WriterT<^Monad<'T*'Monoid>>
Modifiers: inline
m : ^Monad<'T>
Returns: WriterT<^Monad<'T*'Monoid>>

WriterT.Lift2(f, x, y)

Full Usage: WriterT.Lift2(f, x, y)

Parameters:
    f : 'T -> 'U -> 'V
    x : WriterT<^Monad<'T*'Monoid>>
    y : WriterT<^Monad<'U*'Monoid>>

Returns: WriterT<^Monad<'V*'Monoid>>
Modifiers: inline
f : 'T -> 'U -> 'V
x : WriterT<^Monad<'T*'Monoid>>
y : WriterT<^Monad<'U*'Monoid>>
Returns: WriterT<^Monad<'V*'Monoid>>

WriterT.Lift3(f, x, y, z)

Full Usage: WriterT.Lift3(f, x, y, z)

Parameters:
    f : 'T -> 'U -> 'V -> 'W
    x : WriterT<^Monad<'T*'Monoid>>
    y : WriterT<^Monad<'U*'Monoid>>
    z : WriterT<^Monad<'V*'Monoid>>

Returns: WriterT<^Monad<'W*'Monoid>>
Modifiers: inline
f : 'T -> 'U -> 'V -> 'W
x : WriterT<^Monad<'T*'Monoid>>
y : WriterT<^Monad<'U*'Monoid>>
z : WriterT<^Monad<'V*'Monoid>>
Returns: WriterT<^Monad<'W*'Monoid>>

WriterT.LiftAsync(x)

Full Usage: WriterT.LiftAsync(x)

Parameters:
Returns: WriterT<^MonadAsync<'T>>
Modifiers: inline
x : Async<'T>
Returns: WriterT<^MonadAsync<'T>>

WriterT.Listen(arg1)

Full Usage: WriterT.Listen(arg1)

Parameters:
    arg0 : WriterT<^Monad<'T*'Monoid>>

Returns: WriterT<^Monad<('T*'Monoid)*'Monoid>>
Modifiers: inline
arg0 : WriterT<^Monad<'T*'Monoid>>
Returns: WriterT<^Monad<('T*'Monoid)*'Monoid>>

WriterT.Local(arg1, f)

Full Usage: WriterT.Local(arg1, f)

Parameters:
    arg0 : WriterT<^a>
    f : 'R1 -> 'R2

Returns: WriterT<^MonadReader<'R1,'T*'Monoid>>
Modifiers: inline
Type parameters: 'R1, 'R2, ^MonadReader<'R1,'T*'Monoid>
arg0 : WriterT<^a>
f : 'R1 -> 'R2
Returns: WriterT<^MonadReader<'R1,'T*'Monoid>>

WriterT.Map(x, f)

Full Usage: WriterT.Map(x, f)

Parameters:
    x : WriterT<^Monad<'T*'Monoid>>
    f : 'T -> 'U

Returns: WriterT<^Monad<'U*'Monoid>>
Modifiers: inline
x : WriterT<^Monad<'T*'Monoid>>
f : 'T -> 'U
Returns: WriterT<^Monad<'U*'Monoid>>

WriterT.Pass(arg1)

Full Usage: WriterT.Pass(arg1)

Parameters:
    arg0 : WriterT<^Monad<('T*('Monoid->'Monoid))*'Monoid>>

Returns: WriterT<^Monad<'T*'Monoid>>
Modifiers: inline
arg0 : WriterT<^Monad<('T*('Monoid->'Monoid))*'Monoid>>
Returns: WriterT<^Monad<'T*'Monoid>>

WriterT.Put(x)

Full Usage: WriterT.Put(x)

Parameters:
    x : 'S

Returns: WriterT<^MonadState<'S,unit*'Monoid>>
Modifiers: inline
x : 'S
Returns: WriterT<^MonadState<'S,unit*'Monoid>>

WriterT.Return(x)

Full Usage: WriterT.Return(x)

Parameters:
    x : 'T

Returns: WriterT<^Monad<'T*'Monoid>>
Modifiers: inline
x : 'T
Returns: WriterT<^Monad<'T*'Monoid>>

WriterT.Tell(w)

Full Usage: WriterT.Tell(w)

Parameters:
    w : 'Monoid

Returns: WriterT<^Monad>
Modifiers: inline
Type parameters: ^Monad<unit * 'Monoid>
w : 'Monoid
Returns: WriterT<^Monad>

WriterT.Throw(x)

Full Usage: WriterT.Throw(x)

Parameters:
    x : 'E

Returns: WriterT<^a>
Modifiers: inline
x : 'E
Returns: WriterT<^a>

WriterT.TryFinally(computation, f)

Full Usage: WriterT.TryFinally(computation, f)

Parameters:
    computation : WriterT<^Monad<'T*'Monoid>>
    f : unit -> unit

Returns: WriterT<^Monad<'T*'Monoid>>
Modifiers: inline
computation : WriterT<^Monad<'T*'Monoid>>
f : unit -> unit
Returns: WriterT<^Monad<'T*'Monoid>>

WriterT.TryWith(source, f)

Full Usage: WriterT.TryWith(source, f)

Parameters:
    source : WriterT<^Monad<'T*'Monoid>>
    f : exn -> WriterT<^Monad<'T*'Monoid>>

Returns: WriterT<^Monad<'T*'Monoid>>
Modifiers: inline
source : WriterT<^Monad<'T*'Monoid>>
f : exn -> WriterT<^Monad<'T*'Monoid>>
Returns: WriterT<^Monad<'T*'Monoid>>

WriterT.Using(resource, f)

Full Usage: WriterT.Using(resource, f)

Parameters:
    resource : 'a
    f : 'a -> WriterT<^Monad<'T*'Monoid>>

Returns: WriterT<^Monad<'T*'Monoid>>
Modifiers: inline
Type parameters: ^Monad<'T * 'Monoid>
resource : 'a
f : 'a -> WriterT<^Monad<'T*'Monoid>>
Returns: WriterT<^Monad<'T*'Monoid>>

WriterT.get_Ask ()

Full Usage: WriterT.get_Ask ()

Returns: WriterT<^MonadReader<'R,'R*'Monoid>>
Modifiers: inline
Returns: WriterT<^MonadReader<'R,'R*'Monoid>>

WriterT.get_Empty ()

Full Usage: WriterT.get_Empty ()

Returns: WriterT<^MonadPlus<'T*'Monoid>>
Modifiers: inline
Returns: WriterT<^MonadPlus<'T*'Monoid>>

WriterT.get_Get ()

Full Usage: WriterT.get_Get ()

Returns: WriterT<^MonadState<'S,'S*'Monoid>>
Modifiers: inline
Returns: WriterT<^MonadState<'S,'S*'Monoid>>