package preface

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

Parameters

Signature

include Preface_specs.FREE_SELECTIVE with type 'a f = 'a F.t
type 'a f = 'a F.t

The type held by the Preface_specs.Functor.

The type held by the Free selective.

type _ t =
  1. | Pure : 'a -> 'a t
  2. | Select : ('a, 'b) Either.t t * ('a -> 'b) f -> 'b t
val promote : 'a f -> 'a t

Promote a value from the Preface_specs.Functor into the Free selective.

module To_selective (Selective : Preface_specs.Selective.CORE) : Preface_specs.Free_selective.TO_SELECTIVE with type 'a t := 'a t and type 'a f := 'a f and type 'a selective := 'a Selective.t

The natural transformation from a Free selective to an other Preface_specs.Selective.

module To_monoid (Monoid : Preface_specs.Monoid.CORE) : Preface_specs.Free_selective.TO_MONOID with type 'a t := 'a t and type 'a f := 'a f and type monoid := Monoid.t

The natural transformation from a Free selective to a Preface_specs.Monoid.

Selective API

A Free selective is also a Preface_specs.Selective.

Type

Functions

val select : ('a, 'b) Preface_core.Shims.Either.t t -> ('a -> 'b) t -> 'b t

select e f apply f if e is Left. It allow to skip effect using Right.

val branch : ('a, 'b) Preface_core.Shims.Either.t t -> ('a -> 'c) t -> ('b -> 'c) t -> 'c t

branch is like select. It chooses between two effects.

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

Applicative functor of ('a -> 'b) t over 'a t to 'b t.

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

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

val product : 'a t -> 'b t -> ('a * 'b) t

Product functor mapping from 'a t and 'b t to ('a * 'b) t.

val pure : 'a -> 'a t

Lift a value from 'a into a new 'a 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 lift : ('a -> 'b) -> 'a t -> 'b t

Mapping over from 'a to 'b over 'a t to 'b 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.

val if_ : bool t -> 'a t -> 'a t -> 'a t

Same of branch but using a Boolean as disjunction.

val bind_bool : bool t -> (bool -> 'a t) -> 'a t

Monad bind specialized for Boolean.

val when_ : bool t -> unit t -> unit t

Conditionnally perform an effect.

val exists : ('a -> bool t) -> 'a list -> bool t

Selective version of List.exists.

val for_all : ('a -> bool t) -> 'a list -> bool t

Selective version of List.for_all.

val or_ : bool t -> bool t -> bool t

Or combinator.

val and_ : bool t -> bool t -> bool t

And combinator.

val while_ : bool t -> unit t

Keep checking an effectful condition while it holds.

Infix operators

module Infix : Preface_specs.Selective.INFIX with type 'a t := 'a t
val (<*>) : ('a -> 'b) t -> 'a t -> 'b t

Applicative functor of ('a -> 'b) t over 'a t to 'b t.

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

Flipped Applicative functor of ('a -> 'b) t over 'a t to 'b t.

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

Discard the value of the first argument.

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

Discard the value of the second argument.

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.

val (<*?) : ('a, 'b) Preface_core.Shims.Either.t t -> ('a -> 'b) t -> 'b t

Infix version of CORE.select.

val (<||>) : bool t -> bool t -> bool t

Infix version of CORE.or_.

val (<&&>) : bool t -> bool t -> bool t

Infix version of CORE.and_.

Syntax

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

Flipped mapping over from 'a to 'b over 'a t to 'b t.

val and+ : 'a t -> 'b t -> ('a * 'b) t

Product functor mapping from 'a t and 'b t to ('a * 'b) t.

val run : 'a t -> 'a f
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