Make2 (p.travesty.0.7.2.doc.travesty.Travesty.State

Parameters

module M : Base.Monad.S

Signature

include Base.Monad.S2

Sourcetype ('a, 'e) t

Sourceval (>>=) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t

Sourceval (>>|) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t

Sourcemodule Let_syntax : sig ... end

Sourcemodule Monad_infix : sig ... end

Same as Infix, except the monad type has two arguments. The second is always just passed through.

Sourceval bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t

Sourceval map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t

Sourceval join : (('a, 'e) t, 'e) t -> ('a, 'e) t

Sourceval ignore_m : (_, 'e) t -> (unit, 'e) t

Sourceval all : ('a, 'e) t list -> ('a list, 'e) t

Sourceval all_unit : (unit, 'e) t list -> (unit, 'e) t

include State_transform_types.Generic
  with type ('a, 's) t := ('a, 's) t
   and type 's state := 's
  with module Inner = M

include State_transform_types.Generic_builders
  with type 'a final := 'a
  with type ('a, 's) t := ('a, 's) t
  with type 's state := 's

include State_transform_types.Generic_types
  with type 'a final := 'a
  with type ('a, 's) t := ('a, 's) t
  with type 's state := 's

Sourceval make : ('s -> 's * 'a) -> ('a, 's) t

make creates a context-sensitive computation that can modify both the current context and the data passing through.

Specialised builders

Sourceval peek : ('s -> 'a) -> ('a, 's) t

peek creates a context-sensitive computation that can look at the current context, but not modify it.

Sourceval modify : ('s -> 's) -> (Base.unit, 's) t

modify creates a context-sensitive computation that can look at and modify the current context.

Sourceval return : 'a -> ('a, 's) t

return lifts a value or monad into a stateful computation.

Sourcemodule Inner = M

Inner is the monad to which we're adding state.

State transformers have the same runner signatures as state monads, but lifted into the inner monad.

include State_transform_types.Generic_runners
  with type ('a, 's) t := ('a, 's) t
   and type 'a final := 'a Inner.t
   and type 's state := 's

include State_transform_types.Generic_types
  with type ('a, 's) t := ('a, 's) t
  with type 'a final := 'a Inner.t
  with type 's state := 's

Sourceval run' : ('a, 's) t -> 's -> ('s * 'a) Inner.t

run' unfolds a t into a function from context to final state and result.

Sourceval run : ('a, 's) t -> 's -> 'a Inner.t

run unfolds a t into a function from context to final result. To get the final context, use run' or call peek at the end of the computation.

include State_transform_types.Fix with type ('a, 's) t := ('a, 's) t

Sourceval fix : f:(('a -> ('a, 's) t) -> 'a -> ('a, 's) t) -> 'a -> ('a, 's) t

fix ~f init builds a fixed point on f.

At each step, f is passed a continuation mu and a value a. It may choose to return a recursive application of mu, or some value derived from a.

To begin with, f is applied to mu and init.

Source

module Monadic : 
  State_transform_types.Generic_builders
    with type 'a state := 'a
     and type 'a final := 'a Inner.t
     and type ('a, 's) t := ('a, 's) t

Monadic contains a version of the builder interface that can interact with the inner monad (Inner) this state transformer is overlaying.