State_transform.To_S
To_S
flattens a S2 into an S by fixing the state type to B.t
.
module M : State_transform_types.S2
include Base.Monad.S with type 'a t = ('a, B.t) M.t
type 'a t = ('a, B.t) M.t
module Monad_infix : sig ... end
module Let_syntax : sig ... end
include Monad_exts_types.S with type 'a t := 'a t
S
subsumes S_let
.
then_m x y
sequentially composes the actions x
and y
as with >>=
, but, rather than using the returned value of x
, it instead just returns y
.
compose_m f g
is the Kleisli composition of f
and g
.
map_when_m ?otherwise condition ~f a
is f a
when condition
is true, and otherwise a
(by default, return
) otherwise.
when_m ?otherwise condition ~f
is f ()
when condition
is true, and otherwise ()
(by default, return
) otherwise.
map_unless_m ?otherwise condition ~f a
is f a
when condition
is false, and otherwise a
(by default, return
) otherwise.
unless_m ?otherwise condition ~f
is f ()
when condition
is false, and otherwise ()
(by default, return
) otherwise.
tee_m val ~f
executes f val
for its monadic action, then returns val
.
Example (using an extended Or_error):
let fail_if_negative x =
On_error.when_m (Int.is_negative x) ~f:(fun () ->
Or_error.error_string "value is negative!" )
in
Or_error.(42 |> tee_m ~f:fail_if_negative >>| fun x -> x * x)
(* Ok (1764) *)
val tee : 'a -> f:('a -> unit) -> 'a t
tee val ~f
behaves as tee_m
, but takes a non-monadic f
.
Example (using an extended Or_error):
let print_if_negative x =
if Int.negative x then Stdio.print_string "value is negative!"
in
Or_error.(
try_get_value () >>= tee ~f:print_if_negative >>= try_use_value () )
include State_transform_types.Generic
with type ('a, 's) t := 'a t
and type 's state := state
with module Inner = M.Inner
include State_transform_types.Generic_builders
with type 'a final := 'a
with type ('a, 's) t := 'a t
with type 's state := state
make
creates a context-sensitive computation that can modify both the current context and the data passing through.
peek
creates a context-sensitive computation that can look at the current context, but not modify it.
modify
creates a context-sensitive computation that can look at and modify the current context.
val return : 'a -> 'a t
return
lifts a value or monad into a stateful computation.
module Inner = M.Inner
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.Fix with type ('a, 's) t := 'a t