package preface

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

Source file monad.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
open QCheck2

module Suite
    (R : Model.COVARIANT_1)
    (F : Preface_specs.MONAD with type 'a t = 'a R.t)
    (A : Model.T0)
    (B : Model.T0)
    (C : Model.T0)
    (D : Model.T0) =
struct
  module Bind = Bind.Suite (R) (F) (A) (B) (C) (D)
  module Laws = Preface_laws.Monad.For (F)

  let print pp = Format.asprintf "%a" (R.pp pp)

  let monad_1 count =
    let generator = R.generator A.generator in
    let print = print A.pp in
    Util.test ~count ~print generator Laws.monad_1 (fun lhs rhs x ->
        let left, id_left = lhs x
        and right, id_right = rhs x in
        R.equal A.equal left right
        && R.equal A.equal left id_left
        && R.equal A.equal right id_right )
  ;;

  let monad_2 count =
    let generator = Gen.tup2 (fun1 A.observable B.generator) A.generator in
    let print (_, x) = Format.asprintf "%a" A.pp x in
    Util.test ~count ~print generator Laws.monad_2 (fun lhs rhs (ff, x) ->
        let f = Fn.apply ff in
        let left = lhs f x
        and right = rhs f x in
        R.equal B.equal left right )
  ;;

  let monad_3 count =
    let generator =
      Gen.tup2 A.generator (fun1 A.observable (R.generator B.generator))
    in
    let print (x, _) = Format.asprintf "%a" A.pp x in
    Util.test ~count ~print generator Laws.monad_3 (fun lhs rhs (x, ff) ->
        let f = Fn.apply ff in
        let left = lhs x f
        and right = rhs x f in
        R.equal B.equal left right )
  ;;

  let monad_4 count =
    let generator = R.generator A.generator in
    let print = print A.pp in
    Util.test ~count ~print generator Laws.monad_4 (fun lhs rhs x ->
        let left = lhs x
        and right = rhs x in
        R.equal A.equal left right )
  ;;

  let monad_5 count =
    let generator =
      Gen.tup2 A.generator (fun1 A.observable (R.generator B.generator))
    in
    let print (x, _) = Format.asprintf "%a" A.pp x in
    Util.test ~count ~print generator Laws.monad_5 (fun lhs rhs (x, ff) ->
        let f = Fn.apply ff in
        let left = lhs x f
        and right = rhs x f in
        R.equal B.equal left right )
  ;;

  let monad_6 count =
    let generator =
      Gen.tup2 A.generator (fun1 A.observable (R.generator B.generator))
    in
    let print (x, _) = Format.asprintf "%a" A.pp x in
    Util.test ~count ~print generator Laws.monad_6 (fun lhs rhs (x, ff) ->
        let f = Fn.apply ff in
        let left = lhs x f
        and right = rhs x f in
        R.equal B.equal left right )
  ;;

  let tests ~count =
    Bind.tests ~count
    @ [
        monad_1 count
      ; monad_2 count
      ; monad_3 count
      ; monad_4 count
      ; monad_5 count
      ; monad_6 count
      ]
  ;;
end
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