package yocaml

  1. Overview
  2. Docs
package yocaml
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Yocaml.ValidateSource

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

Sourcetype 'a t = ('a, Error.t Preface.Nonempty_list.t) Preface.Validation.t

A specialised version of Validation.

Constructors

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

Sourceval valid : 'a -> 'a t

Produces a valid value.

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

Produces an invalid value.

Sourceval error : Error.t -> 'a t

Produces an invalid value using an Error.

Conversions

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

Produces a Try from a Validate.

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

Produces a Validate from a Try.

Helpers

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

Pretty-printers for Validate.t.

Sourceval 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.

module Applicative : Preface.Specs.Traversable.API_OVER_APPLICATIVE with type 'a t = 'a t

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.

module Monad : Preface.Specs.Traversable.API_OVER_MONAD with type 'a t = 'a t

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

Infix and Syntax operators

Sourcemodule Infix : sig ... end
Sourcemodule 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
include Preface.Specs.Selective.INFIX with type 'a t := 'a t
val (<*>) : ('a -> 'b) t -> 'a t -> 'b t
val (<**>) : 'a t -> ('a -> 'b) t -> 'b t
val (*>) : unit t -> 'a t -> 'a t
val (<*) : 'a t -> unit t -> 'a t
val (<*?) : ('a, 'b) Preface_core.Shims.Either.t t -> ('a -> 'b) t -> 'b t
val (<||>) : bool t -> bool t -> bool t
val (<&&>) : bool t -> bool t -> bool t
include Preface.Specs.Monad.INFIX with type 'a t := 'a t
val (=|<) : ('a -> 'b) -> 'a t -> 'b t
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val (=<<) : ('a -> 'b t) -> 'a t -> 'b t
val (>=>) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val (<=<) : ('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
val (>>) : unit t -> 'b t -> 'b t
val (<<) : 'a t -> unit t -> 'a t
val (<$>) : ('a -> 'b) -> 'a t -> 'b t
val (<&>) : 'a t -> ('a -> 'b) -> 'b t
val (<$) : 'a -> 'b t -> 'a t
val ($>) : 'a t -> 'b -> 'b t
include module type of Syntax with type 'a t := 'a t
include Preface.Specs.Selective.SYNTAX with type 'a t := 'a t
val (and+) : 'a t -> 'b t -> ('a * 'b) t
include Preface.Specs.Monad.SYNTAX with type 'a t := 'a t
val (let*) : 'a t -> ('a -> 'b t) -> 'b t
val (let+) : 'a t -> ('a -> 'b) -> 'b t