package preface

  1. Overview
  2. Docs
package preface
Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

Signature

type state = State.t

The encapsulated state.

type 'a monad

The inner monad.

type 'a t = state -> ('a * state) monad

The type held by the state monad.

val upper : 'a monad -> 'a t

promote monad into the transformation.

val eval : 'a t -> state -> 'a monad

Unwrap the state computation and extract the current value.

val exec : 'a t -> state -> state monad

Unwrap the state computation and extract the current state.

val run : 'a t -> state -> ('a * state) monad

Unwrap the state computation.

val state : (state -> 'a * state) -> 'a t

Lift a function into a state.

val get : state t

Returns the current state.

val set : state -> unit t

Replace the state with the given one.

val modify : (state -> state) -> unit t

Modify the state applying the given function.

val gets : (state -> 'a) -> 'a t

Apply a function to the current state and return it.

Monad

Type
Functions
val bind : ('a -> 'b t) -> 'a t -> 'b t

bind f m passes the result of computation m to function f.

val map : ('a -> 'b) -> 'a t -> 'b t

Mapping over from 'a to 'b over 'a t to 'b t.

val join : 'a t t -> 'a t

join remove one level of monadic structure, projecting its bound argument into the outer level.

val return : 'a -> 'a t

Create a new 'a t.

val compose_left_to_right : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t

Composing monadic functions using Kleisli Arrow (from left to right).

val compose_right_to_left : ('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t

Composing monadic functions using Kleisli Arrow (from right to left).

val lift : ('a -> 'b) -> 'a t -> 'b t

Mapping over from 'a to 'b over 'a t to 'b t.

val lift2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

Mapping over from 'a and 'b to 'c over 'a t and 'b t to 'c t.

val lift3 : ('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t

Mapping over from 'a and 'b and 'c to 'd over 'a t and 'b t and 'c t to 'd t.

val replace : 'a -> 'b t -> 'a t

Create a new 'a t, replacing all values in the 'b t by given a value of 'a.

val void : 'a t -> unit t

Create a new unit t, replacing all values in the 'a t by unit.

Infix operators
module Infix : Preface_specs.Monad.INFIX with type 'a t := 'a t
val (=|<) : ('a -> 'b) -> 'a t -> 'b t

Infix version of CORE.map.

val (>|=) : 'a t -> ('a -> 'b) -> 'b t

Infix flipped version of CORE.map.

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t

Infix flipped version of CORE.bind.

val (=<<) : ('a -> 'b t) -> 'a t -> 'b t

Infix version of CORE.bind.

val (>=>) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t

Infix version of CORE.compose_left_to_right.

val (<=<) : ('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t

Infix version of OPERATION.compose_right_to_left.

val (>>) : unit t -> 'b t -> 'b t

Sequentially compose two actions, discarding any value produced by the first.

val (<<) : 'a t -> unit t -> 'a t

Sequentially compose two actions, discarding any value produced by the second.

val (<$>) : ('a -> 'b) -> 'a t -> 'b t

Infix version of Preface_specs.Functor.CORE.map.

val (<&>) : 'a t -> ('a -> 'b) -> 'b t

Flipped and infix version of Preface_specs.Functor.CORE.map.

val (<$) : 'a -> 'b t -> 'a t

Infix version of Preface_specs.Functor.OPERATION.replace.

val ($>) : 'a t -> 'b -> 'b t

Flipped and infix version of Preface_specs.Functor.OPERATION.replace.

Syntax
module Syntax : Preface_specs.Monad.SYNTAX with type 'a t := 'a t
val let* : 'a t -> ('a -> 'b t) -> 'b t

Syntaxic shortcuts for flipped version of CORE.bind:

let* x = e in f is equals to bind (fun x -> f) e.

val let+ : 'a t -> ('a -> 'b) -> 'b t

Syntaxic shortcuts for flipped version of CORE.map:

let+ x = e in f is equals to map (fun x -> f) e.

val run_identity : 'a t -> State.t -> 'a * State.t

Run the state through the identity.

val exec_identity : 'a t -> State.t -> State.t

Exec the state through the identity.

val eval_identity : 'a t -> State.t -> 'a

Eval the state through the identity.

Functor

module Functor : Preface_specs.FUNCTOR with type 'a t = 'a t

Applicative

module Applicative : Preface_specs.APPLICATIVE with type 'a t = 'a t
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct