package yocaml

  1. Overview
  2. Docs

A specialised version of Validation (with a nonempty list of Error.t as Invalid part). Validate is very useful to produce parallel validations, where each error is accumulated, as opposed to Try which stops the computation at the first error.

Type

A specialised version of Validation.

Constructors

Production of valid (Valid) or invalid (Inavlid) values.

val valid : 'a -> 'a t

Produces a valid value.

val invalid : Error.t Preface.Nonempty_list.t -> 'a t

Produces an invalid value.

val error : Error.t -> 'a t

Produces an invalid value using an Error.

Conversions

val to_try : 'a t -> ('a, Error.t) Preface.Result.t

Produces a Try from a Validate.

val from_try : ('a, Error.t) Preface.Result.t -> 'a t

Produces a Validate from a Try.

Helpers

val pp : (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a t -> unit

Pretty-printers for Validate.t.

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

Equality betweens Validate.t.

Implementation

Some implementations of some abstractions offered by Preface.

module Functor : Preface.Specs.FUNCTOR with type 'a t = 'a t

Validate is a Functor that (logically) implements map.

Validate is an Applicative that (logically) implements apply and pure.

module Alt : Preface.Specs.Alt.API with type 'a t = 'a t

Validate is an Alt that (logically) implements combine.

module Selective : Preface.Specs.SELECTIVE with type 'a t = 'a t

Validate is a Selective that (logically) implements select and branch.

Validate is also a Monad that (logically) implements bind and return.

Infix and Syntax operators

module Infix : sig ... end
module Syntax : sig ... end
include module type of Infix with type 'a t := 'a t
include Preface.Specs.Alt.INFIX with type 'a t := 'a t
val (<|>) : 'a t -> 'a t -> 'a t

Infix version of CORE.combine

include Preface.Specs.Selective.INFIX with type 'a t := 'a t
include Preface_specs.Apply.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) 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_.

include 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
val (<&>) : 'a t -> ('a -> 'b) -> 'b t

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

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

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

include module type of Syntax with type 'a t := 'a t
include Preface.Specs.Selective.SYNTAX with type 'a t := 'a t
include Preface_specs.Apply.SYNTAX with type 'a t := 'a t
val and+ : 'a t -> 'b t -> ('a * 'b) t

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

include Preface.Specs.Monad.SYNTAX with type 'a t := 'a t
val let* : 'a t -> ('a -> 'b t) -> 'b t

Syntactic 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

Syntactic shortcuts for flipped version of CORE.map:

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

OCaml

Innovation. Community. Security.