package yocaml

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Type
Constructors
Conversions
Helpers
Implementation
Infix and Syntax operators

yocaml
- Yocaml
  - Build
    
    Infix
  - Date
  - Deps
    
    Monoid
    
    Infix
    
    Writer
    
    Infix
    
    Monad
    
    Infix
    
    Syntax
    
    Syntax
  - Effect
    
    Applicative
    
    Infix
    
    Syntax
    
    Freer
    
    Applicative
    
    Infix
    
    Syntax
    
    Functor
    
    Infix
    
    Infix
    
    Monad
    
    Infix
    
    Syntax
    
    Selective
    
    Infix
    
    Syntax
    
    Syntax
    
    To_monad
    
    Monad
    
    Functor
    
    Infix
    
    Infix
    
    Monad
    
    Infix
    
    Syntax
    
    Selective
    
    Infix
    
    Syntax
    
    Syntax
    
    To_monad
    
    Monad
    
    Traverse
  - Error
  - Filepath
  - Key_value
    
    DESCRIBABLE
    
    Jsonm_descriptor
    
    Jsonm_object
    
    Jsonm_validator
    
    Make_validator
    
    KV
    
    VALIDABLE
    
    VALIDATOR
  - Languages
    
    ISO639
  - Lexicon
  - Log
  - Metadata
    
    Article
    
    Articles
    
    Date
    
    INJECTABLE
    
    Page
    
    READABLE
    
    RENDERABLE
    
    VALIDABLE
  - Mime
  - Rss
    
    Category
    
    Channel
    
    Cloud
    
    Enclosure
    
    Guid
    
    Image
    
    Item
    
    Source
  - Runtime
    
    Make
    
    R
    
    RUNTIME
  - Try
    
    Applicative
    
    Infix
    
    Syntax
    
    Traversable
    
    A
    
    Infix
    
    Syntax
    
    Functor
    
    Infix
    
    Infix
    
    Monad
    
    Infix
    
    Syntax
    
    Traversable
    
    M
    
    Infix
    
    Syntax
    
    Syntax
  - Util
  - Validate
    
    Alt
    
    Infix
    
    Applicative
    
    Infix
    
    Syntax
    
    Traversable
    
    A
    
    Infix
    
    Syntax
    
    Functor
    
    Infix
    
    Infix
    
    Monad
    
    Infix
    
    Syntax
    
    Traversable
    
    M
    
    Infix
    
    Syntax
    
    Selective
    
    Infix
    
    Syntax
    
    Syntax

Legend:
Library
Module
Module type
Parameter
Class
Class type

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

type '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.

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.

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

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

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.

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.