package preface

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

Source file foldable.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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
module Core_via_fold_right (Req : Preface_specs.Foldable.WITH_FOLD_RIGHT) =
struct
  type 'a t = 'a Req.t

  include (
    Indexed_foldable.Core_via_fold_right (struct
      type ('a, 'index) t = 'a Req.t

      include (
        Req : Preface_specs.Foldable.WITH_FOLD_RIGHT with type 'a t := 'a Req.t )
    end) :
      Preface_specs.Indexed_foldable.CORE with type ('a, _) t := 'a Req.t )
end

module Core_via_fold_map (Req : Preface_specs.Foldable.WITH_FOLD_MAP) = struct
  type 'a t = 'a Req.t

  include (
    Indexed_foldable.Core_via_fold_map (struct
      type ('a, 'index) t = 'a Req.t

      include (
        Req : Preface_specs.Foldable.WITH_FOLD_MAP with type 'a t := 'a Req.t )
    end) :
      Preface_specs.Indexed_foldable.CORE with type ('a, _) t := 'a Req.t )
end

module Operation (C : Preface_specs.Foldable.CORE) = struct
  type 'a t = 'a C.t

  include (
    Indexed_foldable.Operation (struct
      type ('a, 'index) t = 'a C.t

      include (C : Preface_specs.Foldable.CORE with type 'a t := 'a C.t)
    end) :
      Preface_specs.Indexed_foldable.OPERATION with type ('a, _) t := 'a C.t )
end

module Via
    (C : Preface_specs.Foldable.CORE)
    (O : Preface_specs.Foldable.OPERATION with type 'a t = 'a C.t) =
struct
  type 'a t = 'a C.t

  include (
    Indexed_foldable.Via
      (struct
        type ('a, 'index) t = 'a C.t

        include (C : Preface_specs.Foldable.CORE with type 'a t := 'a C.t)
      end)
      (struct
        type ('a, 'index) t = 'a C.t

        include (O : Preface_specs.Foldable.OPERATION with type 'a t := 'a C.t)
      end) :
      Preface_specs.Indexed_foldable.API with type ('a, _) t := 'a C.t )
end

module Via_fold_right (Req : Preface_specs.Foldable.WITH_FOLD_RIGHT) = struct
  type 'a t = 'a Req.t

  include (
    Indexed_foldable.Via_fold_right (struct
      type ('a, 'index) t = 'a Req.t

      include (
        Req : Preface_specs.Foldable.WITH_FOLD_RIGHT with type 'a t := 'a Req.t )
    end) :
      Preface_specs.Indexed_foldable.API with type ('a, _) t := 'a Req.t )
end

module Via_fold_map (Req : Preface_specs.Foldable.WITH_FOLD_MAP) = struct
  type 'a t = 'a Req.t

  include (
    Indexed_foldable.Via_fold_map (struct
      type ('a, 'index) t = 'a Req.t

      include (
        Req : Preface_specs.Foldable.WITH_FOLD_MAP with type 'a t := 'a Req.t )
    end) :
      Preface_specs.Indexed_foldable.API with type ('a, _) t := 'a Req.t )
end

module Composition (F : Preface_specs.FOLDABLE) (G : Preface_specs.FOLDABLE) =
Via_fold_map (struct
  type 'a t = 'a G.t F.t

  let fold_map' neutral combine f x =
    F.fold_map' neutral combine (G.fold_map' neutral combine f) x
  ;;
end)

module Sum (F : Preface_specs.FOLDABLE) (G : Preface_specs.FOLDABLE) = struct
  type 'a sum =
    | L of 'a F.t
    | R of 'a G.t

  include Via_fold_map (struct
    type 'a t = 'a sum

    let fold_map' neutral combine f = function
      | L x -> F.fold_map' neutral combine f x
      | R x -> G.fold_map' neutral combine f x
    ;;
  end)
end

module Product (F : Preface_specs.FOLDABLE) (G : Preface_specs.FOLDABLE) =
Via_fold_map (struct
  type 'a t = 'a F.t * 'a G.t

  let fold_map' neutral combine f (x, y) =
    combine (F.fold_map' neutral combine f x) (G.fold_map' neutral combine f y)
  ;;
end)

module Index (F : Preface_specs.FOLDABLE) = struct
  type ('a, 'index) t = 'a F.t

  include (
    Indexed_foldable.Via
      (struct
        type nonrec ('a, 'index) t = ('a, 'index) t

        include (F : Preface_specs.Foldable.CORE with type 'a t := 'a F.t)
      end)
      (struct
        type nonrec ('a, 'index) t = ('a, 'index) t

        include (F : Preface_specs.Foldable.OPERATION with type 'a t := 'a F.t)
      end) :
      Preface_specs.INDEXED_FOLDABLE with type ('a, 'index) t := ('a, 'index) t )
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