package preface

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

Source file option.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
type 'a t = 'a option

let pure x = Some x

module Foldable = Preface_make.Foldable.Via_fold_right (struct
  type nonrec 'a t = 'a t

  let fold_right f x acc = match x with None -> acc | Some v -> f v acc
end)

module Functor = Preface_make.Functor.Via_map (struct
  type nonrec 'a t = 'a t

  let map f = function Some x -> Some (f x) | None -> None
end)

module Alternative = Preface_make.Alternative.Via_pure_and_apply (struct
  type nonrec 'a t = 'a t

  let pure = pure

  let apply fa xa =
    match (fa, xa) with Some f, Some x -> Some (f x) | _ -> None
  ;;

  let neutral = None
  let combine l r = match (l, r) with None, x -> x | x, _ -> x
end)

let traverse_aux pure map f = function
  | None -> pure None
  | Some x -> map Stdlib.Option.some (f x)
;;

module Applicative_traversable (A : Preface_specs.APPLICATIVE) =
  Preface_make.Traversable.Over_applicative
    (A)
    (struct
      type 'a t = 'a A.t
      type 'a iter = 'a option

      let traverse f x = traverse_aux A.pure A.map f x
    end)

module Applicative =
  Preface_make.Traversable.Join_with_applicative
    (Alternative)
    (Applicative_traversable)

module Monad_internal = Preface_make.Monad.Via_return_and_bind (struct
  type nonrec 'a t = 'a t

  let return x = Some x
  let bind f = function Some x -> f x | None -> None
end)

module Monad_traversable (M : Preface_specs.MONAD) =
  Preface_make.Traversable.Over_monad
    (M)
    (struct
      type 'a t = 'a M.t
      type 'a iter = 'a option

      let traverse f x = traverse_aux M.return M.map f x
    end)

module Monad =
  Preface_make.Traversable.Join_with_monad (Monad_internal) (Monad_traversable)

module Selective =
  Preface_make.Selective.Over_applicative_via_select
    (Applicative)
    (Preface_make.Selective.Select_from_monad (Monad))

module Monad_plus =
  Preface_make.Monad_plus.Over_monad_and_alternative (Monad) (Alternative)

module Invariant = Preface_make.Invariant.From_functor (Functor)

module Monoid (M : Preface_specs.SEMIGROUP) =
Preface_make.Monoid.Via_combine_and_neutral (struct
  type nonrec t = M.t t

  let neutral = None

  let combine x y =
    match (x, y) with
    | None, result | result, None -> result
    | Some a, Some b -> Some (M.combine a b)
  ;;
end)

let equal f left right =
  match (left, right) with
  | None, None -> true
  | Some x, Some y -> f x y
  | _ -> false
;;

let pp pp' formater = function
  | None -> Format.fprintf formater "None"
  | Some x -> Format.fprintf formater "Some (%a)" pp' x
;;

let if_ p value = if p value then Some value else None
let unless p = if_ (Predicate.negate p)
let or_ a b = match a with Some x -> Some x | None -> b
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