Prelude/Collection.ad

Outline
module Prelude.Collection
Collection (typeclass)
insert (declaration + definition)
fromList (declaration + definition)
singleton (declaration + definition)
memberP (declaration)
isEmptyP (declaration)
isEmptyP_ok (property)
isEmptyP_empty (property)
memberP_insert (property)
memberP_fromList (property)
empty (declaration + definition)
union (declaration + definition)
image (declaration + definition)
CollectionWithEmptynessTest (typeclass)
isEmpty (declaration)
isEmptyP_eq_isEmpty (property)
CollectionWithMembershipTest (typeclass)
occur (declaration)
member (declaration + definition)
occur_insert_1 (test)
occur_insert_2 (test)
memberP_member (property)
CollectionWithDelete (typeclass)
delete (declaration)
filter (declaration + definition)
difference (declaration)
intersection (declaration)
partition (declaration + definition)
member_filter (test)
occur_filter (test)
occur_delete (test)
member_delete (test)
intersection_ok (test)
difference_ok (test)
FiniteCollection (typeclass)
empty_size (test)
null_ok (test)
size_fromToList (test)
size_toFromList (test)
elem_ok (test)
memberP_toList (property)
member_elem (test)
CollectionWithSubsetTest (typeclass)
disjoint (declaration)
isSubsetOf (declaration)
isProperSubsetOf (declaration)
isSetEquiv (declaration + definition)
disjoint (definition)
disjoint_ok (test)
isSubsetOf_ok (test)
isProperSubsetOf_ok (test)
SetLike (typeclass)
noDups_occur (test)
setEmpty (declaration + definition)
setInsert (declaration + definition)
setFromList (declaration + definition)
BagLike (typeclass)
occur_insert_bag (test)
Set (typeclass)
FiniteSet (typeclass)
Bag (typeclass)
FiniteBag (typeclass)

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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

module Prelude.Collection (
  Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c(..)class-constant `fromList`
class-constant `insert`
class-constant `isEmptyP`
class-constant `memberP`
class-constant `singleton`
,
  emptyconstant `Prelude.Collection.empty`
   constant
   type `Collection 'c 'e => 'c`
   executable,
  unionconstant `Prelude.Collection.union`
   constant
   type `Collection 'c 'e => 'c -> 'c -> 'c`
   executable,
  imageconstant `Prelude.Collection.image`
   constant
   type `(!Functor 'C, Collection ('C 'e1) 'e1, Collection ('C 'e2) 'e2) => ('e1 -> 'e2) -> 'C 'e1 -> 'C 'e2`
   executable,

  setEmptyconstant `Prelude.Collection.setEmpty`
   constant
   type `SetLike 'c 'e => 'c`
   executable,
  setInsertconstant `Prelude.Collection.setInsert`
   constant
   type `SetLike 'c 'e => 'e -> 'c -> 'c`
   executable,
  setFromListconstant `Prelude.Collection.setFromList`
   constant
   type `SetLike 'c 'e => ['e] -> 'c`
   executable,

  CollectionWithEmptynessTesttype-class `Prelude.Collection.CollectionWithEmptynessTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e(..)class-constant `isEmpty`
,
  CollectionWithMembershipTesttype-class `Prelude.Collection.CollectionWithMembershipTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e(..)class-constant `member`
class-constant `occur`
,
  CollectionWithDeletetype-class `Prelude.Collection.CollectionWithDelete`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Eq.Eq 'e
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e(..)class-constant `delete`
class-constant `difference`
class-constant `filter`
class-constant `intersection`
class-constant `partition`
,
  FiniteCollectiontype-class `Prelude.Collection.FiniteCollection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e
     - Prelude.Foldable.Foldable 'c 'e
     - Prelude.Collection.CollectionWithEmptynessTest 'c 'e(..),
  CollectionWithSubsetTesttype-class `Prelude.Collection.CollectionWithSubsetTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithDelete 'c 'e
     - Prelude.Collection.CollectionWithEmptynessTest 'c 'e(..)class-constant `disjoint`
class-constant `isProperSubsetOf`
class-constant `isSetEquiv`
class-constant `isSubsetOf`
,
  SetLiketype-class `Prelude.Collection.SetLike`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e(..),
  BagLiketype-class `Prelude.Collection.BagLike`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e(..),
  Settype-class `Prelude.Collection.Set`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.SetLike 'c 'e
     - Prelude.Collection.CollectionWithDelete 'c 'e
     - Prelude.Collection.CollectionWithEmptynessTest 'c 'e(..),
  FiniteSettype-class `Prelude.Collection.FiniteSet`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Set 'c 'e
     - Prelude.Collection.FiniteCollection 'c 'e(..),
  Bagtype-class `Prelude.Collection.Bag`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.BagLike 'c 'e
     - Prelude.Collection.CollectionWithDelete 'c 'e
     - Prelude.Collection.CollectionWithEmptynessTest 'c 'e(..),
  FiniteBagtype-class `Prelude.Collection.FiniteBag`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Bag 'c 'e
     - Prelude.Collection.FiniteCollection 'c 'e(..)
) where

{-# NoImplicitPrelude #-}

import Prelude.Bool
import Prelude.BasicClasses
import Prelude.Eq
import Prelude.Ord
import Prelude.Function
import Prelude.Tuple
import Prelude.Functor
import Prelude.Foldable
import Prelude.Num
import qualified Prelude.List as List


-- {-# allow-similar-names "isEmptyP_ok", "isEmpty_ok" #-}

-- | A 'Collection' is a container for some elements. Not much is known
-- about this element or the container. There might be a finite or infinite number of elements, elements
-- might occour multiple times, their order might matter or not, there might not be a (decidable) equality on the
-- elements and membership might not be decidable.
-- Via the 'Monoid' type class an empty collection and combining of collections is available.
class Monoidtype-class `Prelude.BasicClasses.Monoid`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.BasicClasses.Semigroup 'a 'ctype-variable `'c`
   kind `*` => Collection 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
  declare insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable :: 'etype-variable `'e`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*`
  define insertconstant `Prelude.Collection.insert`
   default instance of type-class constant
   type `('e -> 'c) -> 'e -> 'c -> 'c`
   executable evariable `e`
   type `'e` cvariable `c`
   type `'c` := (singletonconstant `Prelude.Collection.singleton`
   constant of type-class `Collection`
   type `'e -> 'c`
   executable
   same type-class instance evariable `e`
   type `'e`) <>constant `Prelude.BasicClasses.(<>)`
   constant of type-class `Semigroup`
   type `'a -> 'a -> 'a`
   type in context `'c -> 'c -> 'c`
   executable
   type-class instance from context cvariable `c`
   type `'c`

  declare fromListconstant `Prelude.Collection.fromList`
   constant of type-class `Collection`
   type `['e] -> 'c`
   executable :: ['etype-variable `'e`
   kind `*`] -> 'ctype-variable `'c`
   kind `*`
  define fromListconstant `Prelude.Collection.fromList`
   default instance of type-class constant
   type `('e -> 'c -> 'c) -> ['e] -> 'c`
   executable := foldlconstant `Prelude.Foldable.foldl`
   statically resolved constant of type-class `Foldable`
   type `('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   type in context `('c -> 'e -> 'c) -> 'c -> ['e] -> 'c`
   executable
   statically resolved type-class instance (fntype `'c -> 'e -> 'c` cvariable `c`
   type `'c` evariable `e`
   type `'e` -> insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable
   same type-class instance evariable `e`
   type `'e` cvariable `c`
   type `'c`) memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class `Monoid`
   type `'a`
   type in context `'c`
   executable
   type-class instance from context

  declare singletonconstant `Prelude.Collection.singleton`
   constant of type-class `Collection`
   type `'e -> 'c`
   executable :: 'etype-variable `'e`
   kind `*` -> 'ctype-variable `'c`
   kind `*`
  define singletonconstant `Prelude.Collection.singleton`
   default instance of type-class constant
   type `('e -> 'c -> 'c) -> 'e -> 'c`
   executable evariable `e`
   type `'e` := insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable
   same type-class instance evariable `e`
   type `'e` memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class `Monoid`
   type `'a`
   type in context `'c`
   executable
   type-class instance from context

  declare non-exec memberPconstant `Prelude.Collection.memberP`
   constant of type-class `Collection`
   type `EqP 'e => 'e -> 'c -> Prop`
   non-executable :: EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - full 'etype-variable `'e`
   kind `*` => 'etype-variable `'e`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> Proptype `Prelude.Bool.Prop`
   kind `*`
   non-executable

  declare non-exec isEmptyPconstant `Prelude.Collection.isEmptyP`
   constant of type-class `Collection`
   type `'c -> Prop`
   non-executable :: 'ctype-variable `'c`
   kind `*` -> Proptype `Prelude.Bool.Prop`
   kind `*`
   non-executable
  property EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - full 'etype-variable `'e`
   kind `*` => isEmptyP_okconstant `Prelude.Collection.isEmptyP_ok`
   type-class property
   type `EqP 'e => 'c -> Prop`
   non-executable (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := isEmptyPconstant `Prelude.Collection.isEmptyP`
   constant of type-class `Collection`
   type `'c -> Prop`
   non-executable
   same type-class instance cvariable `c`
   type `'c` <=>constant `Prelude.Bool.(<=>)`
   constant
   type `Prop -> Prop -> Prop`
   non-executable (forallP evariable `e`
   type `'e`. notPconstant `Prelude.Bool.notP`
   constant
   type `Prop -> Prop`
   non-executable (memberPconstant `Prelude.Collection.memberP`
   constant of type-class `Collection`
   type `EqP 'e => 'e -> 'c -> Prop`
   type in context `'e -> 'c -> Prop`
   non-executable
   same type-class instance evariable `e`
   type `'e` cvariable `c`
   type `'c`))
  property isEmptyP_emptyconstant `Prelude.Collection.isEmptyP_empty`
   type-class property
   type `Prop`
   non-executable := isEmptyPconstant `Prelude.Collection.isEmptyP`
   constant of type-class `Collection`
   type `'c -> Prop`
   non-executable
   same type-class instance (memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class `Monoid`
   type `'a`
   type in context `'c`
   executable
   type-class instance from context :: 'ctype-variable `'c`
   kind `*`)

  property EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - full 'etype-variable `'e`
   kind `*` => memberP_insertconstant `Prelude.Collection.memberP_insert`
   type-class property
   type `EqP 'e => 'e -> 'e -> 'c -> Prop`
   non-executable (e1variable `e1`
   type `'e` :: 'etype-variable `'e`
   kind `*`) e2variable `e2`
   type `'e` (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := (memberPconstant `Prelude.Collection.memberP`
   constant of type-class `Collection`
   type `EqP 'e => 'e -> 'c -> Prop`
   type in context `'e -> 'c -> Prop`
   non-executable
   same type-class instance e1variable `e1`
   type `'e` (insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable
   same type-class instance e2variable `e2`
   type `'e` cvariable `c`
   type `'c`) <=>constant `Prelude.Bool.(<=>)`
   constant
   type `Prop -> Prop -> Prop`
   non-executable ((e1variable `e1`
   type `'e` ===constant `Prelude.Eq.(===)`
   constant of type-class `EqP`
   type `'a -> 'a -> Prop`
   type in context `'e -> 'e -> Prop`
   non-executable
   type-class instance from argument e2variable `e2`
   type `'e`) \/constant `Prelude.Bool.(\/)`
   constant
   type `Prop -> Prop -> Prop`
   non-executable memberPconstant `Prelude.Collection.memberP`
   constant of type-class `Collection`
   type `EqP 'e => 'e -> 'c -> Prop`
   type in context `'e -> 'c -> Prop`
   non-executable
   same type-class instance e1variable `e1`
   type `'e` cvariable `c`
   type `'c`))
  property EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - full 'etype-variable `'e`
   kind `*` => memberP_fromListconstant `Prelude.Collection.memberP_fromList`
   type-class property
   type `EqP 'e => 'e -> ['e] -> Prop`
   non-executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (lvariable `l`
   type `['e]` :: ['etype-variable `'e`
   kind `*`]) := (memberPconstant `Prelude.Collection.memberP`
   constant of type-class `Collection`
   type `EqP 'e => 'e -> 'c -> Prop`
   type in context `'e -> 'c -> Prop`
   non-executable
   same type-class instance evariable `e`
   type `'e` ((fromListconstant `Prelude.Collection.fromList`
   constant of type-class `Collection`
   type `['e] -> 'c`
   executable
   same type-class instance lvariable `l`
   type `['e]`)::'ctype-variable `'c`
   kind `*`) <=>constant `Prelude.Bool.(<=>)`
   constant
   type `Prop -> Prop -> Prop`
   non-executable List.elemPconstant `Prelude.List.elemP`
   constant
   type `EqP 'a => 'a -> ['a] -> Prop`
   type in context `'e -> ['e] -> Prop`
   non-executable evariable `e`
   type `'e` lvariable `l`
   type `['e]`)
end-class

declare emptyconstant `Prelude.Collection.empty`
   constant
   type `Collection 'c 'e => 'c`
   executable :: Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => 'ctype-variable `'c`
   kind `*`
define emptyconstant `Prelude.Collection.empty`
   constant
   type `Collection 'c 'e => 'c`
   executable := memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class `Monoid`
   type `'a`
   type in context `'c`
   executable
   type-class instance from argument
{-# inline emptyconstant `Prelude.Collection.empty`
   constant
   type `Collection 'c 'e => 'c`
   executable #-}

declare unionconstant `Prelude.Collection.union`
   constant
   type `Collection 'c 'e => 'c -> 'c -> 'c`
   executable :: Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*`
define unionconstant `Prelude.Collection.union`
   constant
   type `Collection 'c 'e => 'c -> 'c -> 'c`
   executable := (<>)constant `Prelude.BasicClasses.(<>)`
   constant of type-class `Semigroup`
   type `'a -> 'a -> 'a`
   type in context `'c -> 'c -> 'c`
   executable
   type-class instance from argument
{-# inline unionconstant `Prelude.Collection.union`
   constant
   type `Collection 'c 'e => 'c -> 'c -> 'c`
   executable #-}

{-# severity class-constr-unusedclass-constraint is not needed, since it is not used ignore #-}
declare imageconstant `Prelude.Collection.image`
   constant
   type `(!Functor 'C, Collection ('C 'e1) 'e1, Collection ('C 'e2) 'e2) => ('e1 -> 'e2) -> 'C 'e1 -> 'C 'e2`
   executable :: (!Functortype-class `Prelude.Functor.Functor`
   arguments: ('F :: * -> *)
   reserved var-names: 'a, 'b
   statically-resolved 'Ctype-variable `'C`
   kind `* -> *`, Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c ('Ctype-variable `'C`
   kind `* -> *` 'e1type-variable `'e1`
   kind `*`) 'e1type-variable `'e1`
   kind `*`, Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c ('Ctype-variable `'C`
   kind `* -> *` 'e2type-variable `'e2`
   kind `*`) 'e2type-variable `'e2`
   kind `*`) => ('e1type-variable `'e1`
   kind `*` -> 'e2type-variable `'e2`
   kind `*`) -> 'Ctype-variable `'C`
   kind `* -> *` 'e1type-variable `'e1`
   kind `*` -> 'Ctype-variable `'C`
   kind `* -> *` 'e2type-variable `'e2`
   kind `*`
define imageconstant `Prelude.Collection.image`
   constant
   type `(!Functor 'C, Collection ('C 'e1) 'e1, Collection ('C 'e2) 'e2) => ('e1 -> 'e2) -> 'C 'e1 -> 'C 'e2`
   executable := fmapconstant `Prelude.Functor.fmap`
   statically resolved constant of type-class `Functor`
   type `('a -> 'b) -> 'F 'a -> 'F 'b`
   type in context `('e1 -> 'e2) -> 'C 'e1 -> 'C 'e2`
   executable
   type-class instance from argument
{-# inline imageconstant `Prelude.Collection.image`
   constant
   type `(!Functor 'C, Collection ('C 'e1) 'e1, Collection ('C 'e2) 'e2) => ('e1 -> 'e2) -> 'C 'e1 -> 'C 'e2`
   executable #-}
{-# severity class-constr-unusedclass-constraint is not needed, since it is not used reset #-}

class Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => CollectionWithEmptynessTest 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
  declare isEmptyconstant `Prelude.Collection.isEmpty`
   constant of type-class `CollectionWithEmptynessTest`
   type `'c -> Bool`
   executable :: 'ctype-variable `'c`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable

  property isEmptyP_eq_isEmptyconstant `Prelude.Collection.isEmptyP_eq_isEmpty`
   type-class property
   type `'c -> Prop`
   non-executable (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := (isEmptyPconstant `Prelude.Collection.isEmptyP`
   constant of type-class `Collection`
   type `'c -> Prop`
   non-executable
   type-class instance from context cvariable `c`
   type `'c` <=>constant `Prelude.Bool.(<=>)`
   constant
   type `Prop -> Prop -> Prop`
   non-executable (isEmptyconstant `Prelude.Collection.isEmpty`
   constant of type-class `CollectionWithEmptynessTest`
   type `'c -> Bool`
   executable
   same type-class instance cvariable `c`
   type `'c` ===constant `Prelude.Eq.(===)`
   constant of type-class `EqP`
   type `'a -> 'a -> Prop`
   type in context `Bool -> Bool -> Prop`
   non-executable
   statically resolved type-class instance Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable))
end-class


-- | For most collections, we want a decidable membership test. Since elements might occur multiple times
-- there is also a function that returns that number.
class Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => CollectionWithMembershipTest 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
  declare occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   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 `*` -> 'ctype-variable `'c`
   kind `*` -> Naturaldatatype `Prelude.Num.Natural`
   kind `*`
   executable

  declare memberconstant `Prelude.Collection.member`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> 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 `*` -> 'ctype-variable `'c`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable
  define memberconstant `Prelude.Collection.member`
   default instance of type-class constant
   type `Eq 'e => ('e -> 'c -> Natural) -> 'e -> 'c -> Bool`
   executable evariable `e`
   type `'e` cvariable `c`
   type `'c` := (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   same type-class instance evariable `e`
   type `'e` cvariable `c`
   type `'c` >constant `Prelude.Ord.(>)`
   constant of type-class `Ord`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance 0natural number literal
   type `Natural`
   decimal value: 0
   hexadecimal value: 0x0
   octal value: 0o0
   binary value: 0b0)

  test Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => occur_insert_1constant `Prelude.Collection.occur_insert_1`
   type-class test
   type `Eq 'e => 'e -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=
                   (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   same type-class instance evariable `e`
   type `'e` (insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   same type-class instance evariable `e`
   type `'e` cvariable `c`
   type `'c` +constant `Prelude.Num.(+)`
   constant of type-class `NumPlus`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance 1natural number literal
   type `Natural`
   decimal value: 1
   hexadecimal value: 0x1
   octal value: 0o1
   binary value: 0b1) ||constant `Prelude.Bool.(||)`
   constant
   type `Bool -> Bool -> Bool`
   executable
                   ((occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   same type-class instance evariable `e`
   type `'e` (insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance 1natural number literal
   type `Natural`
   decimal value: 1
   hexadecimal value: 0x1
   octal value: 0o1
   binary value: 0b1) &&constant `Prelude.Bool.(&&)`
   constant
   type `Bool -> Bool -> Bool`
   executable (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   same type-class instance evariable `e`
   type `'e` cvariable `c`
   type `'c` ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance 1natural number literal
   type `Natural`
   decimal value: 1
   hexadecimal value: 0x1
   octal value: 0o1
   binary value: 0b1))
  test Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => occur_insert_2constant `Prelude.Collection.occur_insert_2`
   type-class test
   type `Eq 'e => 'e -> 'e -> 'c -> Bool`
   executable (e1variable `e1`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (e2variable `e2`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=
                   (e1variable `e1`
   type `'e` /=constant `Prelude.Eq.(/=)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `'e -> 'e -> Bool`
   executable
   type-class instance from argument e2variable `e2`
   type `'e`) -->constant `Prelude.Bool.(-->)`
   constant
   type `Bool -> Bool -> Bool`
   executable
                   ((occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   same type-class instance e1variable `e1`
   type `'e` (insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable
   type-class instance from context e2variable `e2`
   type `'e` cvariable `c`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   same type-class instance e1variable `e1`
   type `'e` cvariable `c`
   type `'c`))

  property Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => memberP_memberconstant `Prelude.Collection.memberP_member`
   type-class property
   type `Eq 'e => 'e -> 'c -> Prop`
   non-executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=
    (memberPconstant `Prelude.Collection.memberP`
   constant of type-class `Collection`
   type `EqP 'e => 'e -> 'c -> Prop`
   type in context `'e -> 'c -> Prop`
   non-executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c` <=>constant `Prelude.Bool.(<=>)`
   constant
   type `Prop -> Prop -> Prop`
   non-executable (memberconstant `Prelude.Collection.member`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   same type-class instance evariable `e`
   type `'e` cvariable `c`
   type `'c` ===constant `Prelude.Eq.(===)`
   constant of type-class `EqP`
   type `'a -> 'a -> Prop`
   type in context `Bool -> Bool -> Prop`
   non-executable
   statically resolved type-class instance Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable))
end-class

-- | Removing elements is also common. Remember that collections can contain elements multiple times and
-- order of elements might matter or not,
class (Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*`, CollectionWithMembershipTesttype-class `Prelude.Collection.CollectionWithMembershipTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`) => CollectionWithDelete 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
  -- remove the first occurence of an element in a container
  declare deleteconstant `Prelude.Collection.delete`
   constant of type-class `CollectionWithDelete`
   type `'e -> 'c -> 'c`
   executable :: 'etype-variable `'e`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*`

  -- remove all elements not satisfying a predicate from a container, order is preserved
  declare filterconstant `Prelude.Collection.filter`
   constant of type-class `CollectionWithDelete`
   type `('e -> Bool) -> 'c -> 'c`
   executable :: ('etype-variable `'e`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable) -> 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*`
  define filterconstant `Prelude.Collection.filter`
   default instance of type-class constant
   type `(('e -> Bool) -> 'c -> ('c, 'c)) -> ('e -> Bool) -> 'c -> 'c`
   executable pvariable `p`
   type `'e -> Bool` svariable `s`
   type `'c` := fstconstant `Prelude.Tuple.fst`
   constant
   type `('a, 'b) -> 'a`
   type in context `('c, 'c) -> 'c`
   executable (partitionconstant `Prelude.Collection.partition`
   constant of type-class `CollectionWithDelete`
   type `('e -> Bool) -> 'c -> ('c, 'c)`
   executable
   same type-class instance pvariable `p`
   type `'e -> Bool` svariable `s`
   type `'c`)

  declare differenceconstant `Prelude.Collection.difference`
   constant of type-class `CollectionWithDelete`
   type `'c -> 'c -> 'c`
   executable :: 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*`
  declare intersectionconstant `Prelude.Collection.intersection`
   constant of type-class `CollectionWithDelete`
   type `'c -> 'c -> 'c`
   executable :: 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*`

  -- split a container in all elements not satisfying a predicate and the ones that don't, order is preserved
  declare partitionconstant `Prelude.Collection.partition`
   constant of type-class `CollectionWithDelete`
   type `('e -> Bool) -> 'c -> ('c, 'c)`
   executable :: ('etype-variable `'e`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable) -> 'ctype-variable `'c`
   kind `*` -> ('ctype-variable `'c`
   kind `*`, 'ctype-variable `'c`
   kind `*`)
  define partitionconstant `Prelude.Collection.partition`
   default instance of type-class constant
   type `(('e -> Bool) -> 'c -> 'c) -> ('e -> Bool) -> 'c -> ('c, 'c)`
   executable pvariable `p`
   type `'e -> Bool` svariable `s`
   type `'c` := (filterconstant `Prelude.Collection.filter`
   constant of type-class `CollectionWithDelete`
   type `('e -> Bool) -> 'c -> 'c`
   executable
   same type-class instance pvariable `p`
   type `'e -> Bool` svariable `s`
   type `'c`, filterconstant `Prelude.Collection.filter`
   constant of type-class `CollectionWithDelete`
   type `('e -> Bool) -> 'c -> 'c`
   executable
   same type-class instance (notconstant `Prelude.Bool.not`
   constant
   type `Bool -> Bool`
   executable .constant `Prelude.Function.(.)`
   constant of type-class `Dot`
   type `'a -> 'b -> 'c`
   type in context `(Bool -> Bool) -> ('e -> Bool) -> 'e -> Bool`
   executable
   statically resolved type-class instance pvariable `p`
   type `'e -> Bool`) svariable `s`
   type `'c`)


  test member_filterconstant `Prelude.Collection.member_filter`
   type-class test
   type `'e -> 'c -> ('e -> Bool) -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) pvariable `p`
   type `'e -> Bool` :=
    memberconstant `Prelude.Collection.member`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e` (filterconstant `Prelude.Collection.filter`
   constant of type-class `CollectionWithDelete`
   type `('e -> Bool) -> 'c -> 'c`
   executable
   same type-class instance pvariable `p`
   type `'e -> Bool` cvariable `c`
   type `'c`) <->constant `Prelude.Bool.(<->)`
   constant
   type `Bool -> Bool -> Bool`
   executable (memberconstant `Prelude.Collection.member`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c` &&constant `Prelude.Bool.(&&)`
   constant
   type `Bool -> Bool -> Bool`
   executable pvariable `p`
   type `'e -> Bool` evariable `e`
   type `'e`)

  test occur_filterconstant `Prelude.Collection.occur_filter`
   type-class test
   type `'e -> 'c -> ('e -> Bool) -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) pvariable `p`
   type `'e -> Bool` :=
    occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` (filterconstant `Prelude.Collection.filter`
   constant of type-class `CollectionWithDelete`
   type `('e -> Bool) -> 'c -> 'c`
   executable
   same type-class instance pvariable `p`
   type `'e -> Bool` cvariable `c`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance (if pvariable `p`
   type `'e -> Bool` evariable `e`
   type `'e` then occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c` else 0natural number literal
   type `Natural`
   decimal value: 0
   hexadecimal value: 0x0
   octal value: 0o0
   binary value: 0b0)

  test occur_deleteconstant `Prelude.Collection.occur_delete`
   type-class test
   type `'e -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=
    occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` (deleteconstant `Prelude.Collection.delete`
   constant of type-class `CollectionWithDelete`
   type `'e -> 'c -> 'c`
   executable
   same type-class instance evariable `e`
   type `'e` cvariable `c`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance maxconstant `Prelude.Ord.max`
   constant of type-class `Ord`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance 0natural number literal
   type `Natural`
   decimal value: 0
   hexadecimal value: 0x0
   octal value: 0o0
   binary value: 0b0 (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c` -constant `Prelude.Num.(-)`
   constant of type-class `NumMinus`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance 1natural number literal
   type `Natural`
   decimal value: 1
   hexadecimal value: 0x1
   octal value: 0o1
   binary value: 0b1)

  test member_deleteconstant `Prelude.Collection.member_delete`
   type-class test
   type `'e -> 'e -> 'c -> Bool`
   executable (e1variable `e1`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (e2variable `e2`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=
    (e1variable `e1`
   type `'e` /=constant `Prelude.Eq.(/=)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `'e -> 'e -> Bool`
   executable
   type-class instance from context e2variable `e2`
   type `'e`) -->constant `Prelude.Bool.(-->)`
   constant
   type `Bool -> Bool -> Bool`
   executable (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context e1variable `e1`
   type `'e` (deleteconstant `Prelude.Collection.delete`
   constant of type-class `CollectionWithDelete`
   type `'e -> 'c -> 'c`
   executable
   same type-class instance e2variable `e2`
   type `'e` cvariable `c`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context e1variable `e1`
   type `'e` cvariable `c`
   type `'c`)

  test intersection_okconstant `Prelude.Collection.intersection_ok`
   type-class test
   type `'e -> 'c -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (c1variable `c1`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) (c2variable `c2`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=
    occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` (intersectionconstant `Prelude.Collection.intersection`
   constant of type-class `CollectionWithDelete`
   type `'c -> 'c -> 'c`
   executable
   same type-class instance c1variable `c1`
   type `'c` c2variable `c2`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance minconstant `Prelude.Ord.min`
   constant of type-class `Ord`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` c1variable `c1`
   type `'c`) (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` c2variable `c2`
   type `'c`)
  test difference_okconstant `Prelude.Collection.difference_ok`
   type-class test
   type `'e -> 'c -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (c1variable `c1`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) (c2variable `c2`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=
    occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` (differenceconstant `Prelude.Collection.difference`
   constant of type-class `CollectionWithDelete`
   type `'c -> 'c -> 'c`
   executable
   same type-class instance c1variable `c1`
   type `'c` c2variable `c2`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance maxconstant `Prelude.Ord.max`
   constant of type-class `Ord`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance 0natural number literal
   type `Natural`
   decimal value: 0
   hexadecimal value: 0x0
   octal value: 0o0
   binary value: 0b0 (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` c1variable `c1`
   type `'c` -constant `Prelude.Num.(-)`
   constant of type-class `NumMinus`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` c2variable `c2`
   type `'c`)

end-class

-- | A finite collection. One can fold over a finite collection. This means being able to get the size and
-- having decidable membership tests. Moreover, one can now also convert to a list.
class (CollectionWithMembershipTesttype-class `Prelude.Collection.CollectionWithMembershipTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, CollectionWithEmptynessTesttype-class `Prelude.Collection.CollectionWithEmptynessTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`) => FiniteCollection 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
  test empty_sizeconstant `Prelude.Collection.empty_size`
   type-class test
   type `Bool`
   executable := (sizeconstant `Prelude.Foldable.size`
   constant of type-class `Foldable`
   type `'t -> Natural`
   type in context `'c -> Natural`
   executable
   type-class instance from context (emptyconstant `Prelude.Collection.empty`
   constant
   type `Collection 'c 'e => 'c`
   type in context `'c`
   executable :: 'ctype-variable `'c`
   kind `*`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance 0natural number literal
   type `Natural`
   decimal value: 0
   hexadecimal value: 0x0
   octal value: 0o0
   binary value: 0b0)
  test null_okconstant `Prelude.Collection.null_ok`
   type-class test
   type `'c -> Bool`
   executable (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := (isEmptyconstant `Prelude.Collection.isEmpty`
   constant of type-class `CollectionWithEmptynessTest`
   type `'c -> Bool`
   executable
   type-class instance from context cvariable `c`
   type `'c` <->constant `Prelude.Bool.(<->)`
   constant
   type `Bool -> Bool -> Bool`
   executable nullconstant `Prelude.Foldable.null`
   constant of type-class `Foldable`
   type `'t -> Bool`
   type in context `'c -> Bool`
   executable
   type-class instance from context cvariable `c`
   type `'c`)

  test size_fromToListconstant `Prelude.Collection.size_fromToList`
   type-class test
   type `'c -> Bool`
   executable (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := sizeconstant `Prelude.Foldable.size`
   constant of type-class `Foldable`
   type `'t -> Natural`
   type in context `'c -> Natural`
   executable
   type-class instance from context ((fromListconstant `Prelude.Collection.fromList`
   constant of type-class `Collection`
   type `['e] -> 'c`
   executable
   type-class instance from context ((toListconstant `Prelude.Foldable.toList`
   constant of type-class `Foldable`
   type `'t -> ['e]`
   type in context `'c -> ['e]`
   executable
   type-class instance from context cvariable `c`
   type `'c`) :: ['etype-variable `'e`
   kind `*`])) :: 'ctype-variable `'c`
   kind `*`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance sizeconstant `Prelude.Foldable.size`
   constant of type-class `Foldable`
   type `'t -> Natural`
   type in context `'c -> Natural`
   executable
   type-class instance from context cvariable `c`
   type `'c`
  test size_toFromListconstant `Prelude.Collection.size_toFromList`
   type-class test
   type `['e] -> Bool`
   executable (lvariable `l`
   type `['e]` :: ['etype-variable `'e`
   kind `*`]) := sizeconstant `Prelude.Foldable.size`
   constant of type-class `Foldable`
   type `'t -> Natural`
   type in context `'c -> Natural`
   executable
   type-class instance from context ((fromListconstant `Prelude.Collection.fromList`
   constant of type-class `Collection`
   type `['e] -> 'c`
   executable
   type-class instance from context lvariable `l`
   type `['e]`) :: 'ctype-variable `'c`
   kind `*`) <=constant `Prelude.Ord.(<=)`
   constant of type-class `Ord`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance List.lengthconstant `Prelude.List.length`
   constant
   type `['a] -> Natural`
   type in context `['e] -> Natural`
   executable lvariable `l`
   type `['e]`

  test Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => elem_okconstant `Prelude.Collection.elem_ok`
   type-class test
   type `Eq 'e => 'e -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := memberconstant `Prelude.Collection.member`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c` <->constant `Prelude.Bool.(<->)`
   constant
   type `Bool -> Bool -> Bool`
   executable elemconstant `Prelude.Foldable.elem`
   constant of type-class `Foldable`
   type `Eq 'e => 'e -> 't -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c`

  property EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - full 'etype-variable `'e`
   kind `*` => memberP_toListconstant `Prelude.Collection.memberP_toList`
   type-class property
   type `EqP 'e => 'e -> 'c -> Prop`
   non-executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=
    (List.elemPconstant `Prelude.List.elemP`
   constant
   type `EqP 'a => 'a -> ['a] -> Prop`
   type in context `'e -> ['e] -> Prop`
   non-executable evariable `e`
   type `'e` (toListconstant `Prelude.Foldable.toList`
   constant of type-class `Foldable`
   type `'t -> ['e]`
   type in context `'c -> ['e]`
   executable
   type-class instance from context (cvariable `c`
   type `'c`::'ctype-variable `'c`
   kind `*`)) <=>constant `Prelude.Bool.(<=>)`
   constant
   type `Prop -> Prop -> Prop`
   non-executable memberPconstant `Prelude.Collection.memberP`
   constant of type-class `Collection`
   type `EqP 'e => 'e -> 'c -> Prop`
   type in context `'e -> 'c -> Prop`
   non-executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c`)

  test Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => member_elemconstant `Prelude.Collection.member_elem`
   type-class test
   type `Eq 'e => 'e -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := (elemconstant `Prelude.Foldable.elem`
   constant of type-class `Foldable`
   type `Eq 'e => 'e -> 't -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c` <->constant `Prelude.Bool.(<->)`
   constant
   type `Bool -> Bool -> Bool`
   executable memberconstant `Prelude.Collection.member`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c`)
end-class


-- | collections might consider the order of elements. If we ignore the order,
-- we can define datatypes like sets and bags (multisets)
class (CollectionWithDeletetype-class `Prelude.Collection.CollectionWithDelete`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Eq.Eq 'e
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, CollectionWithEmptynessTesttype-class `Prelude.Collection.CollectionWithEmptynessTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`) => CollectionWithSubsetTest 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
  declare disjointconstant `Prelude.Collection.disjoint`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   executable :: 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable

  declare isSubsetOfconstant `Prelude.Collection.isSubsetOf`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   executable :: 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable
  declare isProperSubsetOfconstant `Prelude.Collection.isProperSubsetOf`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   executable :: 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable

  declare isSetEquivconstant `Prelude.Collection.isSetEquiv`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   executable :: 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> Booldatatype `Prelude.Bool.Bool`
   kind `*`
   executable
  define isSetEquivconstant `Prelude.Collection.isSetEquiv`
   default instance of type-class constant
   type `('c -> 'c -> Bool) -> 'c -> 'c -> Bool`
   executable xsvariable `xs`
   type `'c` ysvariable `ys`
   type `'c` := isSubsetOfconstant `Prelude.Collection.isSubsetOf`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   executable
   same type-class instance xsvariable `xs`
   type `'c` ysvariable `ys`
   type `'c` &&constant `Prelude.Bool.(&&)`
   constant
   type `Bool -> Bool -> Bool`
   executable isSubsetOfconstant `Prelude.Collection.isSubsetOf`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   executable
   same type-class instance ysvariable `ys`
   type `'c` xsvariable `xs`
   type `'c`

  define disjointconstant `Prelude.Collection.disjoint`
   default instance of type-class constant
   type `'c -> 'c -> Bool`
   executable xsvariable `xs`
   type `'c` ysvariable `ys`
   type `'c` := isEmptyconstant `Prelude.Collection.isEmpty`
   constant of type-class `CollectionWithEmptynessTest`
   type `'c -> Bool`
   executable
   type-class instance from context (intersectionconstant `Prelude.Collection.intersection`
   constant of type-class `CollectionWithDelete`
   type `'c -> 'c -> 'c`
   executable
   type-class instance from context xsvariable `xs`
   type `'c` ysvariable `ys`
   type `'c`)

  test disjoint_okconstant `Prelude.Collection.disjoint_ok`
   type-class test
   type `'e -> 'c -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (c1variable `c1`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) (c2variable `c2`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := notconstant `Prelude.Bool.not`
   constant
   type `Bool -> Bool`
   executable (memberconstant `Prelude.Collection.member`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e` c1variable `c1`
   type `'c` &&constant `Prelude.Bool.(&&)`
   constant
   type `Bool -> Bool -> Bool`
   executable memberconstant `Prelude.Collection.member`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Bool`
   type in context `'e -> 'c -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e` c2variable `c2`
   type `'c`)
  test isSubsetOf_okconstant `Prelude.Collection.isSubsetOf_ok`
   type-class test
   type `'e -> 'c -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (c1variable `c1`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) (c2variable `c2`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` c1variable `c1`
   type `'c` <=constant `Prelude.Ord.(<=)`
   constant of type-class `Ord`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` c2variable `c2`
   type `'c`)
  test isProperSubsetOf_okconstant `Prelude.Collection.isProperSubsetOf_ok`
   type-class test
   type `'c -> 'c -> Bool`
   executable (c1variable `c1`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) (c2variable `c2`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) :=  (isSubsetOfconstant `Prelude.Collection.isSubsetOf`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   executable
   same type-class instance c1variable `c1`
   type `'c` c2variable `c2`
   type `'c`) &&constant `Prelude.Bool.(&&)`
   constant
   type `Bool -> Bool -> Bool`
   executable notconstant `Prelude.Bool.not`
   constant
   type `Bool -> Bool`
   executable (isSubsetOfconstant `Prelude.Collection.isSubsetOf`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   executable
   same type-class instance c2variable `c2`
   type `'c` c1variable `c1`
   type `'c`)

end-class

class CollectionWithMembershipTesttype-class `Prelude.Collection.CollectionWithMembershipTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => SetLike 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
  test Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => noDups_occurconstant `Prelude.Collection.noDups_occur`
   type-class test
   type `Eq 'e => 'e -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c` <=constant `Prelude.Ord.(<=)`
   constant of type-class `Ord`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance 1natural number literal
   type `Natural`
   decimal value: 1
   hexadecimal value: 0x1
   octal value: 0o1
   binary value: 0b1
end-class

declare setEmptyconstant `Prelude.Collection.setEmpty`
   constant
   type `SetLike 'c 'e => 'c`
   executable :: SetLiketype-class `Prelude.Collection.SetLike`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => 'ctype-variable `'c`
   kind `*`
define setEmptyconstant `Prelude.Collection.setEmpty`
   constant
   type `SetLike 'c 'e => 'c`
   executable := memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class `Monoid`
   type `'a`
   type in context `'c`
   executable
   type-class instance from argument
{-# inline setEmptyconstant `Prelude.Collection.setEmpty`
   constant
   type `SetLike 'c 'e => 'c`
   executable #-}

declare setInsertconstant `Prelude.Collection.setInsert`
   constant
   type `SetLike 'c 'e => 'e -> 'c -> 'c`
   executable :: SetLiketype-class `Prelude.Collection.SetLike`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => 'etype-variable `'e`
   kind `*` -> 'ctype-variable `'c`
   kind `*` -> 'ctype-variable `'c`
   kind `*`
define setInsertconstant `Prelude.Collection.setInsert`
   constant
   type `SetLike 'c 'e => 'e -> 'c -> 'c`
   executable := insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable
   type-class instance from argument
{-# inline setInsertconstant `Prelude.Collection.setInsert`
   constant
   type `SetLike 'c 'e => 'e -> 'c -> 'c`
   executable #-}

declare setFromListconstant `Prelude.Collection.setFromList`
   constant
   type `SetLike 'c 'e => ['e] -> 'c`
   executable :: SetLiketype-class `Prelude.Collection.SetLike`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => ['etype-variable `'e`
   kind `*`] -> 'ctype-variable `'c`
   kind `*`
define setFromListconstant `Prelude.Collection.setFromList`
   constant
   type `SetLike 'c 'e => ['e] -> 'c`
   executable := fromListconstant `Prelude.Collection.fromList`
   constant of type-class `Collection`
   type `['e] -> 'c`
   executable
   type-class instance from argument
{-# inline setFromListconstant `Prelude.Collection.setFromList`
   constant
   type `SetLike 'c 'e => ['e] -> 'c`
   executable #-}

class CollectionWithMembershipTesttype-class `Prelude.Collection.CollectionWithMembershipTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` => BagLike 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
  test Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => occur_insert_bagconstant `Prelude.Collection.occur_insert_bag`
   type-class test
   type `Eq 'e => 'e -> 'c -> Bool`
   executable (evariable `e`
   type `'e` :: 'etype-variable `'e`
   kind `*`) (cvariable `c`
   type `'c` :: 'ctype-variable `'c`
   kind `*`) := (occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` (insertconstant `Prelude.Collection.insert`
   constant of type-class `Collection`
   type `'e -> 'c -> 'c`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance occurconstant `Prelude.Collection.occur`
   constant of type-class `CollectionWithMembershipTest`
   type `Eq 'e => 'e -> 'c -> Natural`
   type in context `'e -> 'c -> Natural`
   executable
   type-class instance from context evariable `e`
   type `'e` cvariable `c`
   type `'c` +constant `Prelude.Num.(+)`
   constant of type-class `NumPlus`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance 1natural number literal
   type `Natural`
   decimal value: 1
   hexadecimal value: 0x1
   octal value: 0o1
   binary value: 0b1)
end-class

class (SetLiketype-class `Prelude.Collection.SetLike`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, CollectionWithDeletetype-class `Prelude.Collection.CollectionWithDelete`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Eq.Eq 'e
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, CollectionWithEmptynessTesttype-class `Prelude.Collection.CollectionWithEmptynessTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`) => Set 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
end-class

class (Settype-class `Prelude.Collection.Set`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.SetLike 'c 'e
     - Prelude.Collection.CollectionWithDelete 'c 'e
     - Prelude.Collection.CollectionWithEmptynessTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, FiniteCollectiontype-class `Prelude.Collection.FiniteCollection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e
     - Prelude.Foldable.Foldable 'c 'e
     - Prelude.Collection.CollectionWithEmptynessTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`) => FiniteSet 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
end-class

class (BagLiketype-class `Prelude.Collection.BagLike`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, CollectionWithDeletetype-class `Prelude.Collection.CollectionWithDelete`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Eq.Eq 'e
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, CollectionWithEmptynessTesttype-class `Prelude.Collection.CollectionWithEmptynessTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`) => Bag 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
end-class

class (Bagtype-class `Prelude.Collection.Bag`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.BagLike 'c 'e
     - Prelude.Collection.CollectionWithDelete 'c 'e
     - Prelude.Collection.CollectionWithEmptynessTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`, FiniteCollectiontype-class `Prelude.Collection.FiniteCollection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e
     - Prelude.Foldable.Foldable 'c 'e
     - Prelude.Collection.CollectionWithEmptynessTest 'c 'e 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*`) => FiniteBag 'ctype-variable `'c`
   kind `*` 'etype-variable `'e`
   kind `*` | 'c -> 'e where
end-class

end-moduleend of module Prelude.Collection