package octez-libs

  1. Overview
  2. Docs
package octez-libs
Legend:
Library
Module
Module type
Parameter
Class
Class type

The main purpose of this module is to be used with parametric types such as ('a, Empty.t) result. Such type is actually isomorphic to 'a (see get_ok function). This is useful if a module signature expects a generic ('a,'b) result type, but for some instantiation, 'b is actually empty. Here is a small example how such module can be used:

module type S = sig

    type error

    type 'a t

    val return : 'a -> 'a t

    val fail : error -> 'a t

    val bind : 'a t -> ('a -> 'a t) -> (error -> 'a t) -> 'a t end

  module M : S with type error = Empty.t and type 'a t = ('a,
Empty.t) result = struct

    type error = Empty.t

    type 'a t = ('a, Empty.t) result

    let return = fun x -> Ok x

    let fail = Empty.absurd

    let bind = fun data left _right -> match data with | Ok x ->
left x | Error err -> Empty.absurd err end

  let _ = let data = M.bind (M.return 5) (fun x -> M.return (x +
2)) (Empty.absurd) in assert (data |> Empty.get_ok = 7)
type t = |

This type has no canonical inhabitant (there is no terminating OCaml value which inhabits this type).

val get_ok : ('a, t) Stdlib.result -> 'a

get_ok r eliminates the impossible case. This function is total and does not raise any exception.

val absurd : t -> 'a

absurd empty allows constructing any type from the absurd case. This is useful to typecheck impossible branches, e.g.

Result.fold ~ok:(fun i -> i + 1) ~error:Empty.absurd (Ok 41)

Note that this particular example using `result` can be rewritten as:

let i = Empty.get_ok (Ok 41) in i + 1
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