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
- CHANGES
- README
- Library yocaml
  - Yocaml
    
    Build
    
    Infix
    
    Deps
    
    Monoid
    
    Writer
    
    Effect
    
    Freer
    
    Infix
    
    Syntax
    
    To_monad
    
    Functor
    
    Infix
    
    Applicative
    
    Infix
    
    Syntax
    
    Selective
    
    Infix
    
    Syntax
    
    Monad
    
    Infix
    
    Syntax
    
    Traverse
    
    Error
    
    Try
    
    Functor
    
    Applicative
    
    Monad
    
    Infix
    
    Syntax
    
    Validate
    
    Functor
    
    Applicative
    
    Alt
    
    Selective
    
    Monad
    
    Infix
    
    Syntax
    
    Date
    
    Metadata
    
    INJECTABLE
    
    RENDERABLE
    
    VALIDABLE
    
    READABLE
    
    Date
    
    Page
    
    Article
    
    Articles
    
    Key_value
    
    VALIDABLE
    
    VALIDATOR
    
    Make_validator
    
    DESCRIBABLE
    
    Jsonm_object
    
    Jsonm_validator
    
    Jsonm_descriptor
    
    Rss
    
    Image
    
    Category
    
    Enclosure
    
    Source
    
    Guid
    
    Item
    
    Cloud
    
    Channel
    
    Languages
    
    ISO639
    
    Mime
    
    Filepath
    
    Log
    
    Util
    
    Lexicon
    
    Runtime
    
    RUNTIME
    
    Make
    
    Freer
    
    Infix
    
    Syntax
    
    To_monad
    
    Functor
    
    Applicative
    
    Selective
    
    Monad
    
    Traverse
- Sources
  - yocaml
    
    build.ml
    
    date.ml
    
    deps.ml
    
    effect.ml
    
    error.ml
    
    filepath.ml
    
    key_value.ml
    
    languages.ml
    
    lexicon.ml
    
    log.ml
    
    metadata.ml
    
    mime.ml
    
    rss.ml
    
    runtime.ml
    
    try.ml
    
    util.ml
    
    validate.ml
    
    yocaml.ml
    
    yocaml__.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Yocaml.Validate`Source

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