travesty

Traversable containers, monad extensions, and more
IN THIS PACKAGE
Module Travesty . State . M2
include Base.Monad.S2
type ('a, 'e) t
val (>>=) : ( 'a, 'e ) t -> ( 'a -> ( 'b, 'e ) t ) -> ( 'b, 'e ) t
val (>>|) : ( 'a, 'e ) t -> ( 'a -> 'b ) -> ( 'b, 'e ) t
module Let_syntax : sig ... end
module Monad_infix : sig ... end

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

val bind : ( 'a, 'e ) t -> f:( 'a -> ( 'b, 'e ) t ) -> ( 'b, 'e ) t
val map : ( 'a, 'e ) t -> f:( 'a -> 'b ) -> ( 'b, 'e ) t
val join : ( ( 'a, 'e ) t, 'e ) t -> ( 'a, 'e ) t
val ignore_m : ( _, 'e ) t -> ( unit, 'e ) t
val all : ( 'a, 'e ) t list -> ( 'a list, 'e ) t
val all_unit : ( unit, 'e ) t list -> ( unit, 'e ) t
include State_types.Generic with type ('a, 's) t := ( 'a, 's ) t and type 's state := 's and type 'a final := 'a

State monads share the signatures of their builder functions with state transformers...

include State_transform_types.Generic_builders with type ('a, 's) t := ( 'a, 's ) t with type 's state := 's with type 'a final := 'a
include State_transform_types.Generic_types with type ('a, 's) t := ( 'a, 's ) t with type 's state := 's with type 'a final := 'a
val 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

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

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

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

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

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

return lifts a value or monad into a stateful computation.

...as well as their runner functions...

include State_transform_types.Generic_runners with type ('a, 's) t := ( 'a, 's ) t and type 'a final := 'a and type 's state := 's
include State_transform_types.Generic_types with type ('a, 's) t := ( 'a, 's ) t with type 'a final := 'a with type 's state := 's
val run' : ( 'a, 's ) t -> 's -> 's * 'a

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

val run : ( 'a, 's ) t -> 's -> 'a

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.

...and fixed-point combinators.

include State_transform_types.Fix with type ('a, 's) t := ( 'a, 's ) t
val 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.