Prelude/Foldable.ad

Outline

Content

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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
module Prelude.Foldable (
  Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc(..)class-constant `all`
class-constant `any`
class-constant `elem`
class-constant `foldl`
class-constant `foldlWithAbort`
class-constant `foldr`
class-constant `null`
class-constant `size`
class-constant `toList`

) where

{-# NoImplicitPrelude #-}

import Prelude.Function
import Prelude.Bool
import Prelude.Num
import Prelude.Eq
import Prelude.BasicClasses
import Prelude.Unit ()
import           Prelude.List hiding (foldlconstant `Prelude.List.foldl`
   constant
   type `('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
   executable, foldrconstant `Prelude.List.foldr`
   constant
   type `('a -> 'b -> 'b) -> 'b -> ['a] -> 'b`
   executable, foldlWithAbortconstant `Prelude.List.foldlWithAbort`
   constant
   type `('a -> Bool) -> ('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
   executable, elemconstant `Prelude.List.elem`
   constant
   type `Eq 'a => 'a -> ['a] -> Bool`
   executable, lengthconstant `Prelude.List.length`
   constant
   type `['a] -> Natural`
   executable, nullconstant `Prelude.List.null`
   constant
   type `['a] -> Bool`
   executable, allconstant `Prelude.List.all`
   constant
   type `('a -> Bool) -> ['a] -> Bool`
   executable, anyconstant `Prelude.List.any`
   constant
   type `('a -> Bool) -> ['a] -> Bool`
   executable)
import qualified Prelude.List as List
import           Prelude.Maybe hiding (mapconstant `Prelude.Maybe.map`
   constant
   type `('a -> 'b) -> Maybe 'a -> Maybe 'b`
   executable, bindconstant `Prelude.Maybe.bind`
   constant
   type `Maybe 'a -> ('a -> Maybe 'b) -> Maybe 'b`
   executable)

{-# allow-similar-names "foldl", "foldr", "foldlWithAbort", "foldrWithAbort" #-}
class Foldable 'ttype-variable `'t`
   kind `*` 'etype-variable `'e`
   kind `*` | 't -> 'e where

  declare toListconstant `Prelude.Foldable.toList`
   constant of type-class `Foldable`
   type `'t -> ['e]`
   executable :: 'ttype-variable `'t`
   kind `*` -> ['etype-variable `'e`
   kind `*`]

  declare foldrconstant `Prelude.Foldable.foldr`
   statically resolved constant of type-class `Foldable`
   type `('e -> 'acc -> 'acc) -> 'acc -> 't -> 'acc`
   executable :: ('etype-variable `'e`
   kind `*` -> 'acctype-variable `'acc`
   kind `*` -> 'acctype-variable `'acc`
   kind `*`) -> 'acctype-variable `'acc`
   kind `*` -> 'ttype-variable `'t`
   kind `*` -> 'acctype-variable `'acc`
   kind `*`
  {-# static resolve foldrconstant `Prelude.Foldable.foldr`
   statically resolved constant of type-class `Foldable`
   type `('e -> 'acc -> 'acc) -> 'acc -> 't -> 'acc`
   executable #-}

  declare foldlconstant `Prelude.Foldable.foldl`
   statically resolved constant of type-class `Foldable`
   type `('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   executable :: ('acctype-variable `'acc`
   kind `*` -> 'etype-variable `'e`
   kind `*` -> 'acctype-variable `'acc`
   kind `*`) -> 'acctype-variable `'acc`
   kind `*` -> 'ttype-variable `'t`
   kind `*` -> 'acctype-variable `'acc`
   kind `*`
  {-# static resolve foldlconstant `Prelude.Foldable.foldl`
   statically resolved constant of type-class `Foldable`
   type `('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   executable #-}

  declare foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   statically resolved constant of type-class `Foldable`
   type `('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   executable :: ('acctype-variable `'acc`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable) -> ('acctype-variable `'acc`
   kind `*` -> 'etype-variable `'e`
   kind `*` -> 'acctype-variable `'acc`
   kind `*`) -> 'acctype-variable `'acc`
   kind `*` -> 'ttype-variable `'t`
   kind `*` -> 'acctype-variable `'acc`
   kind `*`
  {-# static resolve foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   statically resolved constant of type-class `Foldable`
   type `('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   executable #-}

  declare elemconstant `Prelude.Foldable.elem`
   constant of type-class `Foldable`
   type `Eq 'e => 'e -> 't -> Bool`
   executable :: Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => 'etype-variable `'e`
   kind `*` -> 'ttype-variable `'t`
   kind `*`  -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable
  declare allconstant `Prelude.Foldable.all`
   constant of type-class `Foldable`
   type `('e -> Bool) -> 't -> Bool`
   executable :: ('etype-variable `'e`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable) -> 'ttype-variable `'t`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable
  declare anyconstant `Prelude.Foldable.any`
   constant of type-class `Foldable`
   type `('e -> Bool) -> 't -> Bool`
   executable :: ('etype-variable `'e`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable) -> 'ttype-variable `'t`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable

  declare sizeconstant `Prelude.Foldable.size`
   constant of type-class `Foldable`
   type `'t -> Natural`
   executable :: 'ttype-variable `'t`
   kind `*` -> Naturaldatatype `Prelude.Num.Natural`
   kind `*`
   executable
  declare nullconstant `Prelude.Foldable.null`
   constant of type-class `Foldable`
   type `'t -> Bool`
   executable :: 'ttype-variable `'t`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable

  define foldlconstant `Prelude.Foldable.foldl`
   default instance of type-class constant
   type `('t -> ['e]) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   executable fvariable `f`
   type `'acc -> 'e -> 'acc` avariable `a`
   type `'acc` tvariable `t`
   type `'t` := List.foldlconstant `Prelude.List.foldl`
   constant
   type `('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
   type in context `('acc -> 'e -> 'acc) -> 'acc -> ['e] -> 'acc`
   executable fvariable `f`
   type `'acc -> 'e -> 'acc` avariable `a`
   type `'acc` (toListconstant `Prelude.Foldable.toList`
   constant of type-class `Foldable`
   type `'t -> ['e]`
   executable
   same type-class instance tvariable `t`
   type `'t`)
  define foldrconstant `Prelude.Foldable.foldr`
   default instance of type-class constant
   type `('t -> ['e]) -> ('e -> 'acc -> 'acc) -> 'acc -> 't -> 'acc`
   executable fvariable `f`
   type `'e -> 'acc -> 'acc` avariable `a`
   type `'acc` tvariable `t`
   type `'t` := List.foldrconstant `Prelude.List.foldr`
   constant
   type `('a -> 'b -> 'b) -> 'b -> ['a] -> 'b`
   type in context `('e -> 'acc -> 'acc) -> 'acc -> ['e] -> 'acc`
   executable fvariable `f`
   type `'e -> 'acc -> 'acc` avariable `a`
   type `'acc` (toListconstant `Prelude.Foldable.toList`
   constant of type-class `Foldable`
   type `'t -> ['e]`
   executable
   same type-class instance tvariable `t`
   type `'t`)
  define foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   default instance of type-class constant
   type `('t -> ['e]) -> ('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   executable abortvariable `abort`
   type `'acc -> Bool` fvariable `f`
   type `'acc -> 'e -> 'acc` avariable `a`
   type `'acc` tvariable `t`
   type `'t` := List.foldlWithAbortconstant `Prelude.List.foldlWithAbort`
   constant
   type `('a -> Bool) -> ('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
   type in context `('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> ['e] -> 'acc`
   executable abortvariable `abort`
   type `'acc -> Bool` fvariable `f`
   type `'acc -> 'e -> 'acc` avariable `a`
   type `'acc` (toListconstant `Prelude.Foldable.toList`
   constant of type-class `Foldable`
   type `'t -> ['e]`
   executable
   same type-class instance tvariable `t`
   type `'t`)
  define toListconstant `Prelude.Foldable.toList`
   default instance of type-class constant
   type `(('e -> ['e] -> ['e]) -> ['e] -> 't -> ['e]) -> 't -> ['e]`
   executable := foldrconstant `Prelude.Foldable.foldr`
   statically resolved constant of type-class `Foldable`
   type `('e -> 'acc -> 'acc) -> 'acc -> 't -> 'acc`
   type in context `('e -> ['e] -> ['e]) -> ['e] -> 't -> ['e]`
   executable
   same type-class instance (:)constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   type in context `'e -> ['e] -> ['e]`
   executable []
  define sizeconstant `Prelude.Foldable.size`
   default instance of type-class constant
   type `((Natural -> 'e -> Natural) -> Natural -> 't -> Natural) -> 't -> Natural`
   executable := foldlconstant `Prelude.Foldable.foldl`
   statically resolved constant of type-class `Foldable`
   type `('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   type in context `(Natural -> 'e -> Natural) -> Natural -> 't -> Natural`
   executable
   same type-class instance (fntype `Natural -> 'e -> Natural` avariable `a`
   type `Natural` (_::'etype-variable `'e`
   kind `*`) -> succconstant `Prelude.BasicClasses.succ`
   constant of type-class `Enum`
   type `'a -> 'a`
   type in context `Natural -> Natural`
   executable
   statically resolved type-class instance avariable `a`
   type `Natural`) 0natural number literal
   type `Natural`
   decimal value: 0
   hexadecimal value: 0x0
   octal value: 0o0
   binary value: 0b0
  define nullconstant `Prelude.Foldable.null`
   default instance of type-class constant
   type `((Bool -> Bool) -> (Bool -> 'e -> Bool) -> Bool -> 't -> Bool) -> 't -> Bool`
   executable tvariable `t`
   type `'t` := foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   statically resolved constant of type-class `Foldable`
   type `('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   type in context `(Bool -> Bool) -> (Bool -> 'e -> Bool) -> Bool -> 't -> Bool`
   executable
   same type-class instance notconstant `Prelude.Bool.not`
   constant
   type `Bool -> Bool`
   executable (constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `('e -> Bool) -> Bool -> 'e -> Bool`
   executable (constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Bool -> 'e -> Bool`
   executable Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable)) Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable tvariable `t`
   type `'t`
  define elemconstant `Prelude.Foldable.elem`
   default instance of type-class constant
   type `Eq 'e => (('e -> Bool) -> 't -> Bool) -> 'e -> 't -> Bool`
   executable evariable `e`
   type `'e` := anyconstant `Prelude.Foldable.any`
   constant of type-class `Foldable`
   type `('e -> Bool) -> 't -> Bool`
   executable
   same type-class instance ((==)constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `'e -> 'e -> Bool`
   executable
   type-class instance from argument evariable `e`
   type `'e`)
  define anyconstant `Prelude.Foldable.any`
   default instance of type-class constant
   type `((Bool -> Bool) -> (Bool -> 'e -> Bool) -> Bool -> 't -> Bool) -> ('e -> Bool) -> 't -> Bool`
   executable pvariable `p`
   type `'e -> Bool` tvariable `t`
   type `'t` := foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   statically resolved constant of type-class `Foldable`
   type `('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   type in context `(Bool -> Bool) -> (Bool -> 'e -> Bool) -> Bool -> 't -> Bool`
   executable
   same type-class instance idconstant `Prelude.Function.id`
   constant
   type `'a -> 'a`
   type in context `Bool -> Bool`
   executable (constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `('e -> Bool) -> Bool -> 'e -> Bool`
   executable pvariable `p`
   type `'e -> Bool`) Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable tvariable `t`
   type `'t`
  define allconstant `Prelude.Foldable.all`
   default instance of type-class constant
   type `((Bool -> Bool) -> (Bool -> 'e -> Bool) -> Bool -> 't -> Bool) -> ('e -> Bool) -> 't -> Bool`
   executable pvariable `p`
   type `'e -> Bool` tvariable `t`
   type `'t` := foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   statically resolved constant of type-class `Foldable`
   type `('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   type in context `(Bool -> Bool) -> (Bool -> 'e -> Bool) -> Bool -> 't -> Bool`
   executable
   same type-class instance notconstant `Prelude.Bool.not`
   constant
   type `Bool -> Bool`
   executable (constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `('e -> Bool) -> Bool -> 'e -> Bool`
   executable pvariable `p`
   type `'e -> Bool`) Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable tvariable `t`
   type `'t`

  {-# minimal toList | foldr #-}

end-class

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc ['atype-variable `'a`
   kind `*`] 'atype-variable `'a`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ['a] 'a`
   type `['a] -> ['a]`
   executable := idconstant `Prelude.Function.id`
   constant
   type `'a -> 'a`
   type in context `['a] -> ['a]`
   executable
  {-# inline toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ['a] 'a`
   type `['a] -> ['a]`
   executable #-}

  define foldlconstant `Prelude.Foldable.foldl`
   constant of type-class instance `Foldable ['a] 'a`
   type `('acc -> 'a -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable := List.foldlconstant `Prelude.List.foldl`
   constant
   type `('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
   type in context `('acc -> 'a -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable
  {-# inline foldlconstant `Prelude.Foldable.foldl`
   constant of type-class instance `Foldable ['a] 'a`
   type `('acc -> 'a -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable #-}

  define foldrconstant `Prelude.Foldable.foldr`
   constant of type-class instance `Foldable ['a] 'a`
   type `('a -> 'acc -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable := List.foldrconstant `Prelude.List.foldr`
   constant
   type `('a -> 'b -> 'b) -> 'b -> ['a] -> 'b`
   type in context `('a -> 'acc -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable
  {-# inline foldrconstant `Prelude.Foldable.foldr`
   constant of type-class instance `Foldable ['a] 'a`
   type `('a -> 'acc -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable #-}

  define foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   constant of type-class instance `Foldable ['a] 'a`
   type `('acc -> Bool) -> ('acc -> 'a -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable := List.foldlWithAbortconstant `Prelude.List.foldlWithAbort`
   constant
   type `('a -> Bool) -> ('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
   type in context `('acc -> Bool) -> ('acc -> 'a -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable
  {-# inline foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   constant of type-class instance `Foldable ['a] 'a`
   type `('acc -> Bool) -> ('acc -> 'a -> 'acc) -> 'acc -> ['a] -> 'acc`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ['a] 'a`
   type `['a] -> Natural`
   executable := List.lengthconstant `Prelude.List.length`
   constant
   type `['a] -> Natural`
   executable
  {-# inline sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ['a] 'a`
   type `['a] -> Natural`
   executable #-}

  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ['a] 'a`
   type `['a] -> Bool`
   executable := List.nullconstant `Prelude.List.null`
   constant
   type `['a] -> Bool`
   executable
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ['a] 'a`
   type `['a] -> Bool`
   executable #-}

  define anyconstant `Prelude.Foldable.any`
   constant of type-class instance `Foldable ['a] 'a`
   type `('a -> Bool) -> ['a] -> Bool`
   executable := List.anyconstant `Prelude.List.any`
   constant
   type `('a -> Bool) -> ['a] -> Bool`
   executable
  {-# inline anyconstant `Prelude.Foldable.any`
   constant of type-class instance `Foldable ['a] 'a`
   type `('a -> Bool) -> ['a] -> Bool`
   executable #-}

  define allconstant `Prelude.Foldable.all`
   constant of type-class instance `Foldable ['a] 'a`
   type `('a -> Bool) -> ['a] -> Bool`
   executable := List.allconstant `Prelude.List.all`
   constant
   type `('a -> Bool) -> ['a] -> Bool`
   executable
  {-# inline allconstant `Prelude.Foldable.all`
   constant of type-class instance `Foldable ['a] 'a`
   type `('a -> Bool) -> ['a] -> Bool`
   executable #-}

  declare elemconstant `Prelude.Foldable.elem`
   constant of type-class instance `Foldable ['a] 'a`
   type `Eq 'a => 'a -> ['a] -> Bool`
   executable :: Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'atype-variable `'a`
   kind `*` => 'atype-variable `'a`
   kind `*` -> ['atype-variable `'a`
   kind `*`] -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable
  define elemconstant `Prelude.Foldable.elem`
   constant of type-class instance `Foldable ['a] 'a`
   type `Eq 'a => 'a -> ['a] -> Bool`
   executable := List.elemconstant `Prelude.List.elem`
   constant
   type `Eq 'a => 'a -> ['a] -> Bool`
   type in context `'a -> ['a] -> Bool`
   executable
  {-# inline elemconstant `Prelude.Foldable.elem`
   constant of type-class instance `Foldable ['a] 'a`
   type `Eq 'a => 'a -> ['a] -> Bool`
   executable #-}
end-instance


instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc (Maybedatatype `Prelude.Maybe.Maybe`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`) 'atype-variable `'a`
   kind `*` where

  define foldrconstant `Prelude.Foldable.foldr`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('a -> 'acc -> 'acc) -> 'acc -> Maybe 'a -> 'acc`
   executable _ zvariable `z`
   type `'acc` Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   executable := zvariable `z`
   type `'acc`
       | foldrconstant `Prelude.Foldable.foldr`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('a -> 'acc -> 'acc) -> 'acc -> Maybe 'a -> 'acc`
   executable fvariable `f`
   type `'a -> 'acc -> 'acc` zvariable `z`
   type `'acc` (Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   executable xvariable `x`
   type `'a`) := fvariable `f`
   type `'a -> 'acc -> 'acc` xvariable `x`
   type `'a` zvariable `z`
   type `'acc`

  define foldlconstant `Prelude.Foldable.foldl`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('acc -> 'a -> 'acc) -> 'acc -> Maybe 'a -> 'acc`
   executable _ zvariable `z`
   type `'acc` Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   executable := zvariable `z`
   type `'acc`
       | foldlconstant `Prelude.Foldable.foldl`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('acc -> 'a -> 'acc) -> 'acc -> Maybe 'a -> 'acc`
   executable fvariable `f`
   type `'acc -> 'a -> 'acc` zvariable `z`
   type `'acc` (Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   executable xvariable `x`
   type `'a`) := fvariable `f`
   type `'acc -> 'a -> 'acc` zvariable `z`
   type `'acc` xvariable `x`
   type `'a`

  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `Maybe 'a -> ['a]`
   executable Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   executable := []
       | toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `Maybe 'a -> ['a]`
   executable (Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   executable xvariable `x`
   type `'a`) := [xvariable `x`
   type `'a`]

  define anyconstant `Prelude.Foldable.any`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('a -> Bool) -> Maybe 'a -> Bool`
   executable _ Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   executable := Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
       | anyconstant `Prelude.Foldable.any`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('a -> Bool) -> Maybe 'a -> Bool`
   executable pvariable `p`
   type `'a -> Bool` (Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   executable xvariable `x`
   type `'a`) := pvariable `p`
   type `'a -> Bool` xvariable `x`
   type `'a`

  define allconstant `Prelude.Foldable.all`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('a -> Bool) -> Maybe 'a -> Bool`
   executable _ Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   executable := Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable
       | allconstant `Prelude.Foldable.all`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('a -> Bool) -> Maybe 'a -> Bool`
   executable pvariable `p`
   type `'a -> Bool` (Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   executable xvariable `x`
   type `'a`) := pvariable `p`
   type `'a -> Bool` xvariable `x`
   type `'a`

  define foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('acc -> Bool) -> ('acc -> 'a -> 'acc) -> 'acc -> Maybe 'a -> 'acc`
   executable _ _ zvariable `z`
   type `'acc` Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   executable := zvariable `z`
   type `'acc`
       | foldlWithAbortconstant `Prelude.Foldable.foldlWithAbort`
   constant of type-class instance `Foldable (Maybe 'a) 'a`
   type `('acc -> Bool) -> ('acc -> 'a -> 'acc) -> 'acc -> Maybe 'a -> 'acc`
   executable abvariable `ab`
   type `'acc -> Bool` fvariable `f`
   type `'acc -> 'a -> 'acc` zvariable `z`
   type `'acc` (Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   executable xvariable `x`
   type `'a`) :=
           if (abvariable `ab`
   type `'acc -> Bool` zvariable `z`
   type `'acc`) then zvariable `z`
   type `'acc` else fvariable `f`
   type `'acc -> 'a -> 'acc` zvariable `z`
   type `'acc` xvariable `x`
   type `'a`

end-instance


instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc ('atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`) 'atype-variable `'a`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ('a, 'a) 'a`
   type `('a, 'a) -> ['a]`
   executable (x1variable `x1`
   type `'a`, x2variable `x2`
   type `'a`) := [x1variable `x1`
   type `'a`,x2variable `x2`
   type `'a`]
  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a) 'a`
   type `('a, 'a) -> Bool`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Bool -> ('a, 'a) -> Bool`
   executable Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a) 'a`
   type `('a, 'a) -> Bool`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a) 'a`
   type `('a, 'a) -> Natural`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Natural -> ('a, 'a) -> Natural`
   executable 2natural number literal
   type `Natural`
   decimal value: 2
   hexadecimal value: 0x2
   octal value: 0o2
   binary value: 0b10
  {-# inline sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a) 'a`
   type `('a, 'a) -> Natural`
   executable #-}
end-instance

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc ('atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`) 'atype-variable `'a`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ('a, 'a, 'a) 'a`
   type `('a, 'a, 'a) -> ['a]`
   executable (x1variable `x1`
   type `'a`, x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`) := [x1variable `x1`
   type `'a`,x2variable `x2`
   type `'a`,x3variable `x3`
   type `'a`]
  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a) 'a`
   type `('a, 'a, 'a) -> Bool`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Bool -> ('a, 'a, 'a) -> Bool`
   executable Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a) 'a`
   type `('a, 'a, 'a) -> Bool`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a) 'a`
   type `('a, 'a, 'a) -> Natural`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Natural -> ('a, 'a, 'a) -> Natural`
   executable 3natural number literal
   type `Natural`
   decimal value: 3
   hexadecimal value: 0x3
   octal value: 0o3
   binary value: 0b11
  {-# inline sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a) 'a`
   type `('a, 'a, 'a) -> Natural`
   executable #-}
end-instance

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc ('atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`) 'atype-variable `'a`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a) -> ['a]`
   executable (x1variable `x1`
   type `'a`, x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`) := [x1variable `x1`
   type `'a`,x2variable `x2`
   type `'a`,x3variable `x3`
   type `'a`,x4variable `x4`
   type `'a`]
  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a) -> Bool`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Bool -> ('a, 'a, 'a, 'a) -> Bool`
   executable Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a) -> Bool`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a) -> Natural`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Natural -> ('a, 'a, 'a, 'a) -> Natural`
   executable 4natural number literal
   type `Natural`
   decimal value: 4
   hexadecimal value: 0x4
   octal value: 0o4
   binary value: 0b100
  {-# inline sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a) -> Natural`
   executable #-}
end-instance

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc ('atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`) 'atype-variable `'a`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a) -> ['a]`
   executable (x1variable `x1`
   type `'a`, x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`, x5variable `x5`
   type `'a`) := [x1variable `x1`
   type `'a`,x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`, x5variable `x5`
   type `'a`]
  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a) -> Bool`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Bool -> ('a, 'a, 'a, 'a, 'a) -> Bool`
   executable Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a) -> Bool`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a) -> Natural`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Natural -> ('a, 'a, 'a, 'a, 'a) -> Natural`
   executable 5natural number literal
   type `Natural`
   decimal value: 5
   hexadecimal value: 0x5
   octal value: 0o5
   binary value: 0b101
  {-# inline sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a) -> Natural`
   executable #-}
end-instance

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc ('atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`) 'atype-variable `'a`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a) -> ['a]`
   executable (x1variable `x1`
   type `'a`, x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`, x5variable `x5`
   type `'a`, x6variable `x6`
   type `'a`) := [x1variable `x1`
   type `'a`,x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`, x5variable `x5`
   type `'a`, x6variable `x6`
   type `'a`]
  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Bool -> ('a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Natural -> ('a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable 6natural number literal
   type `Natural`
   decimal value: 6
   hexadecimal value: 0x6
   octal value: 0o6
   binary value: 0b110
  {-# inline sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable #-}
end-instance

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc ('atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`) 'atype-variable `'a`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a) -> ['a]`
   executable (x1variable `x1`
   type `'a`, x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`, x5variable `x5`
   type `'a`, x6variable `x6`
   type `'a`, x7variable `x7`
   type `'a`) := [x1variable `x1`
   type `'a`,x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`, x5variable `x5`
   type `'a`, x6variable `x6`
   type `'a`, x7variable `x7`
   type `'a`]

  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Bool -> ('a, 'a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Natural -> ('a, 'a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable 7natural number literal
   type `Natural`
   decimal value: 7
   hexadecimal value: 0x7
   octal value: 0o7
   binary value: 0b111
  {-# inline sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable #-}
end-instance

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc ('atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`, 'atype-variable `'a`
   kind `*`) 'atype-variable `'a`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) -> ['a]`
   executable (x1variable `x1`
   type `'a`, x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`, x5variable `x5`
   type `'a`, x6variable `x6`
   type `'a`, x7variable `x7`
   type `'a`, x8variable `x8`
   type `'a`) := [x1variable `x1`
   type `'a`,x2variable `x2`
   type `'a`, x3variable `x3`
   type `'a`, x4variable `x4`
   type `'a`, x5variable `x5`
   type `'a`, x6variable `x6`
   type `'a`, x7variable `x7`
   type `'a`, x8variable `x8`
   type `'a`]
  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Bool -> ('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) -> Bool`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable := constantconstant `Prelude.Function.constant`
   constant
   type `'a -> 'b -> 'a`
   type in context `Natural -> ('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable 8natural number literal
   type `Natural`
   decimal value: 8
   hexadecimal value: 0x8
   octal value: 0o10
   binary value: 0b1000
  {-# inline sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable ('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) 'a`
   type `('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a) -> Natural`
   executable #-}
end-instance


end-moduleend of module Prelude.Foldable