Data/Collection/ListBag.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
module Data.Collection.ListBag (
  ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable
) where

import qualified Data.List as List


datatype ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*` := ListBag ['atype-variable `'a`
   kind `*`]

declare emptyListBagconstant `Data.Collection.ListBag.emptyListBag`
   constant
   type `ListBag 'a`
   executable :: ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`
define emptyListBagconstant `Data.Collection.ListBag.emptyListBag`
   constant
   type `ListBag 'a`
   executable := ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   executable []

instance Functortype-class `Prelude.Functor.Functor`
   arguments: ('F :: * -> *)
   reserved var-names: 'a, 'b
   statically-resolved ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable where
  define fmapconstant `Prelude.Functor.fmap`
   constant of type-class instance `Functor ListBag`
   type `('a -> 'b) -> ListBag 'a -> ListBag 'b`
   executable fvariable `f`
   type `'a -> 'b` (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   executable lvariable `l`
   type `['a]`) := ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['b] -> ListBag 'b`
   executable (mapconstant `Prelude.List.map`
   constant
   type `('a -> 'b) -> ['a] -> ['b]`
   executable fvariable `f`
   type `'a -> 'b` lvariable `l`
   type `['a]`)
end-instance

instance Semigrouptype-class `Prelude.BasicClasses.Semigroup`
   arguments: ('a :: *) (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`) where
  define (<>)constant `Prelude.BasicClasses.(<>)`
   constant of type-class instance `Semigroup (ListBag 'a)`
   type `ListBag 'a -> ListBag 'a -> ListBag 'a`
   executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   executable xsvariable `xs`
   type `['a]`) (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   executable ysvariable `ys`
   type `['a]`) := ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   executable (xsvariable `xs`
   type `['a]` ++constant `Prelude.List.(++)`
   constant
   type `['a] -> ['a] -> ['a]`
   executable ysvariable `ys`
   type `['a]`)
end-instance

instance Monoidtype-class `Prelude.BasicClasses.Monoid`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.BasicClasses.Semigroup 'a (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`) where
  define memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class instance `Monoid (ListBag 'a)`
   type `ListBag 'a`
   executable := emptyListBagconstant `Data.Collection.ListBag.emptyListBag`
   constant
   type `ListBag 'a`
   executable
  {-# inline memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class instance `Monoid (ListBag 'a)`
   type `ListBag 'a`
   executable #-}
end-instance

instance CollectionWithEmptynessTesttype-class `Prelude.Collection.CollectionWithEmptynessTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define isEmptyconstant `Prelude.Collection.isEmpty`
   constant of type-class instance `CollectionWithEmptynessTest (ListBag 'e) 'e`
   type `ListBag 'e -> Bool`
   executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`) := (nullconstant `Prelude.Foldable.null`
   constant of type-class `Foldable`
   type `'t -> Bool`
   type in context `['e] -> Bool`
   executable
   statically resolved type-class instance lvariable `l`
   type `['e]`)
end-instance

instance Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define insertconstant `Prelude.Collection.insert`
   constant of type-class instance `Collection (ListBag 'e) 'e`
   type `'e -> ListBag 'e -> ListBag 'e`
   executable evariable `e`
   type `'e` (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`):= ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable (evariable `e`
   type `'e`:constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   type in context `'e -> ['e] -> ['e]`
   executablelvariable `l`
   type `['e]`)
  {-# inline insertconstant `Prelude.Collection.insert`
   constant of type-class instance `Collection (ListBag 'e) 'e`
   type `'e -> ListBag 'e -> ListBag 'e`
   executable #-}

  define fromListconstant `Prelude.Collection.fromList`
   constant of type-class instance `Collection (ListBag 'e) 'e`
   type `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]` := ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`
  {-# inline fromListconstant `Prelude.Collection.fromList`
   constant of type-class instance `Collection (ListBag 'e) 'e`
   type `['e] -> ListBag 'e`
   executable #-}

  define non-exec isEmptyPconstant `Prelude.Collection.isEmptyP`
   constant of type-class instance `Collection (ListBag 'e) 'e`
   type `ListBag 'e -> Prop`
   non-executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`) := bool2propconstant `Prelude.Bool.bool2prop`
   constant
   type `Bool -> Prop`
   non-executable (nullconstant `Prelude.Foldable.null`
   constant of type-class `Foldable`
   type `'t -> Bool`
   type in context `['e] -> Bool`
   executable
   statically resolved type-class instance lvariable `l`
   type `['e]`)
  define non-exec memberPconstant `Prelude.Collection.memberP`
   constant of type-class instance `Collection (ListBag 'e) 'e`
   type `EqP 'e => 'e -> ListBag 'e -> Prop`
   non-executable evariable `e`
   type `'e` (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`) := 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]`
  {-# inline memberPconstant `Prelude.Collection.memberP`
   constant of type-class instance `Collection (ListBag 'e) 'e`
   type `EqP 'e => 'e -> ListBag 'e -> Prop`
   non-executable #-}

end-instance

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable (ListBag 'e) 'e`
   type `ListBag 'e -> ['e]`
   executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`) := lvariable `l`
   type `['e]`
end-instance

instance CollectionWithMembershipTesttype-class `Prelude.Collection.CollectionWithMembershipTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define occurconstant `Prelude.Collection.occur`
   constant of type-class instance `CollectionWithMembershipTest (ListBag 'e) 'e`
   type `Eq 'e => 'e -> ListBag 'e -> Natural`
   executable evariable `e`
   type `'e` (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`) := countconstant `Prelude.List.count`
   constant
   type `Eq 'a => 'a -> ['a] -> Natural`
   type in context `'e -> ['e] -> Natural`
   executable evariable `e`
   type `'e` lvariable `l`
   type `['e]`
  {-# inline occurconstant `Prelude.Collection.occur`
   constant of type-class instance `CollectionWithMembershipTest (ListBag 'e) 'e`
   type `Eq 'e => 'e -> ListBag 'e -> Natural`
   executable #-}

  define memberconstant `Prelude.Collection.member`
   constant of type-class instance `CollectionWithMembershipTest (ListBag 'e) 'e`
   type `Eq 'e => 'e -> ListBag 'e -> Bool`
   executable := elemconstant `Prelude.Foldable.elem`
   constant of type-class `Foldable`
   type `Eq 'e => 'e -> 't -> Bool`
   type in context `'e -> ListBag 'e -> Bool`
   executable
   statically resolved type-class instance
  {-# inline memberconstant `Prelude.Collection.member`
   constant of type-class instance `CollectionWithMembershipTest (ListBag 'e) 'e`
   type `Eq 'e => 'e -> ListBag 'e -> Bool`
   executable #-}

end-instance

instance Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates '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 (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
end-instance



declare listIntersectionconstant `Data.Collection.ListBag.listIntersection`
   constant
   type `Eq 'a => ['a] -> ['a] -> ['a]`
   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 `*`] -> ['atype-variable `'a`
   kind `*`]
define rec listIntersectionconstant `Data.Collection.ListBag.listIntersection`
   constant
   type `Eq 'a => ['a] -> ['a] -> ['a]`
   executable [] _ := []
         | listIntersectionconstant `Data.Collection.ListBag.listIntersection`
   constant
   type `Eq 'a => ['a] -> ['a] -> ['a]`
   executable _ [] := []
         | listIntersectionconstant `Data.Collection.ListBag.listIntersection`
   constant
   type `Eq 'a => ['a] -> ['a] -> ['a]`
   executable (xvariable `x`
   type `'a`:constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   executablexsvariable `xs`
   type `['a]`) lvariable `l`
   type `['a]` :=
              case (takeFirstconstant `Prelude.List.takeFirst`
   constant
   type `('a -> Bool) -> ['a] -> Maybe (['a], 'a)`
   executable ((==)constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   executable
   type-class instance from argument xvariable `x`
   type `'a`) lvariable `l`
   type `['a]`) of
                Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   type in context `Maybe (['a], 'a)`
   executable -> listIntersectionconstant `Data.Collection.ListBag.listIntersection` (recursive usage)
   constant
   type `Eq 'a => ['a] -> ['a] -> ['a]`
   executable xsvariable `xs`
   type `['a]` lvariable `l`
   type `['a]`
              | Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   type in context `(['a], 'a) -> Maybe (['a], 'a)`
   executable (l'variable `l'`
   type `['a]`, _) -> xvariable `x`
   type `'a`:constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   executable(listIntersectionconstant `Data.Collection.ListBag.listIntersection` (recursive usage)
   constant
   type `Eq 'a => ['a] -> ['a] -> ['a]`
   executable xsvariable `xs`
   type `['a]` l'variable `l'`
   type `['a]`)
              end

instance Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates '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 (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define deleteconstant `Prelude.Collection.delete`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `'e -> ListBag 'e -> ListBag 'e`
   executable evariable `e`
   type `'e` (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`) := ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable (removeFirstconstant `Prelude.List.removeFirst`
   constant
   type `('a -> Bool) -> ['a] -> ['a]`
   type in context `('e -> Bool) -> ['e] -> ['e]`
   executable ((==)constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `'e -> 'e -> Bool`
   executable
   type-class instance from context evariable `e`
   type `'e`) lvariable `l`
   type `['e]`)
  {-# inline deleteconstant `Prelude.Collection.delete`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `'e -> ListBag 'e -> ListBag 'e`
   executable #-}

  define filterconstant `Prelude.Collection.filter`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `('e -> Bool) -> ListBag 'e -> ListBag 'e`
   executable pvariable `p`
   type `'e -> Bool` (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`) := ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable (filterconstant `Prelude.Collection.filter`
   constant of type-class `CollectionWithDelete`
   type `('e -> Bool) -> 'c -> 'c`
   type in context `('e -> Bool) -> ['e] -> ['e]`
   executable
   statically resolved type-class instance pvariable `p`
   type `'e -> Bool` lvariable `l`
   type `['e]`)
  {-# inline filterconstant `Prelude.Collection.filter`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `('e -> Bool) -> ListBag 'e -> ListBag 'e`
   executable #-}

  define partitionconstant `Prelude.Collection.partition`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `('e -> Bool) -> ListBag 'e -> (ListBag 'e, ListBag 'e)`
   executable pvariable `p`
   type `'e -> Bool` (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lvariable `l`
   type `['e]`) :=
    let
      val (ltvariable `lt`
   type `['e]`, lfvariable `lf`
   type `['e]`) = List.partitionconstant `Prelude.List.partition`
   constant
   type `('a -> Bool) -> ['a] -> (['a], ['a])`
   type in context `('e -> Bool) -> ['e] -> (['e], ['e])`
   executable pvariable `p`
   type `'e -> Bool` lvariable `l`
   type `['e]`
    in
      (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable ltvariable `lt`
   type `['e]`, ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable lfvariable `lf`
   type `['e]`)
    end
  {-# inline partitionconstant `Prelude.Collection.partition`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `('e -> Bool) -> ListBag 'e -> (ListBag 'e, ListBag 'e)`
   executable #-}

  define differenceconstant `Prelude.Collection.difference`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> ListBag 'e`
   executable := foldlconstant `Prelude.Foldable.foldl`
   statically resolved constant of type-class `Foldable`
   type `('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
   type in context `(ListBag 'e -> 'e -> ListBag 'e) -> ListBag 'e -> ListBag 'e -> ListBag 'e`
   executable
   statically resolved type-class instance (fntype `ListBag 'e -> 'e -> ListBag 'e` lvariable `l`
   type `ListBag 'e` evariable `e`
   type `'e` -> deleteconstant `Prelude.Collection.delete`
   constant of type-class `CollectionWithDelete`
   type `'e -> 'c -> 'c`
   type in context `'e -> ListBag 'e -> ListBag 'e`
   executable
   same type-class instance evariable `e`
   type `'e` lvariable `l`
   type `ListBag 'e`)
  {-# inline differenceconstant `Prelude.Collection.difference`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> ListBag 'e`
   executable #-}

  define intersectionconstant `Prelude.Collection.intersection`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> ListBag 'e`
   executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable l1variable `l1`
   type `['e]`) (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable l2variable `l2`
   type `['e]`) := ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable (listIntersectionconstant `Data.Collection.ListBag.listIntersection`
   constant
   type `Eq 'a => ['a] -> ['a] -> ['a]`
   type in context `['e] -> ['e] -> ['e]`
   executable l1variable `l1`
   type `['e]` l2variable `l2`
   type `['e]`)
  {-# inline intersectionconstant `Prelude.Collection.intersection`
   constant of type-class instance `Eq 'e => CollectionWithDelete (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> ListBag 'e`
   executable #-}
end-instance


declare listSubsetOfconstant `Data.Collection.ListBag.listSubsetOf`
   constant
   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 rec listSubsetOfconstant `Data.Collection.ListBag.listSubsetOf`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable [] _ := Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable
         | listSubsetOfconstant `Data.Collection.ListBag.listSubsetOf`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable _ [] := Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
         | listSubsetOfconstant `Data.Collection.ListBag.listSubsetOf`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable (xvariable `x`
   type `'a`:constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   executablexsvariable `xs`
   type `['a]`) lvariable `l`
   type `['a]` :=
              case (takeFirstconstant `Prelude.List.takeFirst`
   constant
   type `('a -> Bool) -> ['a] -> Maybe (['a], 'a)`
   executable ((==)constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   executable
   type-class instance from argument xvariable `x`
   type `'a`) lvariable `l`
   type `['a]`) of
                Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   type in context `Maybe (['a], 'a)`
   executable -> Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
              | Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   type in context `(['a], 'a) -> Maybe (['a], 'a)`
   executable (l'variable `l'`
   type `['a]`, _) -> listSubsetOfconstant `Data.Collection.ListBag.listSubsetOf` (recursive usage)
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable xsvariable `xs`
   type `['a]` l'variable `l'`
   type `['a]`
              end


declare listSetEquivconstant `Data.Collection.ListBag.listSetEquiv`
   constant
   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 rec listSetEquivconstant `Data.Collection.ListBag.listSetEquiv`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable [] [] := Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable
         | listSetEquivconstant `Data.Collection.ListBag.listSetEquiv`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable [] _ := Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
         | listSetEquivconstant `Data.Collection.ListBag.listSetEquiv`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable _ [] := Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
         | listSetEquivconstant `Data.Collection.ListBag.listSetEquiv`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable (xvariable `x`
   type `'a`:constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   executablexsvariable `xs`
   type `['a]`) lvariable `l`
   type `['a]` :=
              case (takeFirstconstant `Prelude.List.takeFirst`
   constant
   type `('a -> Bool) -> ['a] -> Maybe (['a], 'a)`
   executable ((==)constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   executable
   type-class instance from argument xvariable `x`
   type `'a`) lvariable `l`
   type `['a]`) of
                Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   type in context `Maybe (['a], 'a)`
   executable -> Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
              | Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   type in context `(['a], 'a) -> Maybe (['a], 'a)`
   executable (l'variable `l'`
   type `['a]`, _) -> listSetEquivconstant `Data.Collection.ListBag.listSetEquiv` (recursive usage)
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable xsvariable `xs`
   type `['a]` l'variable `l'`
   type `['a]`
              end

declare listDisjointconstant `Data.Collection.ListBag.listDisjoint`
   constant
   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 rec listDisjointconstant `Data.Collection.ListBag.listDisjoint`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable [] _ := Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable
         | listDisjointconstant `Data.Collection.ListBag.listDisjoint`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable _ [] := Trueconstant `Prelude.Bool.True`
   constructor of datatype `Bool`
   type `Bool`
   executable
         | listDisjointconstant `Data.Collection.ListBag.listDisjoint`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable (xvariable `x`
   type `'a`:constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   executablexsvariable `xs`
   type `['a]`) lvariable `l`
   type `['a]` :=
              case (takeFirstconstant `Prelude.List.takeFirst`
   constant
   type `('a -> Bool) -> ['a] -> Maybe (['a], 'a)`
   executable ((==)constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   executable
   type-class instance from argument xvariable `x`
   type `'a`) lvariable `l`
   type `['a]`) of
                Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   type in context `Maybe (['a], 'a)`
   executable -> listDisjointconstant `Data.Collection.ListBag.listDisjoint` (recursive usage)
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   executable xsvariable `xs`
   type `['a]` lvariable `l`
   type `['a]`
              | Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   type in context `(['a], 'a) -> Maybe (['a], 'a)`
   executable _ -> Falseconstant `Prelude.Bool.False`
   constructor of datatype `Bool`
   type `Bool`
   executable
              end


instance Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => 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 (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define isSubsetOfconstant `Prelude.Collection.isSubsetOf`
   constant of type-class instance `Eq 'e => CollectionWithSubsetTest (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable xsvariable `xs`
   type `['e]`) (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable ysvariable `ys`
   type `['e]`) := listSubsetOfconstant `Data.Collection.ListBag.listSubsetOf`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   type in context `['e] -> ['e] -> Bool`
   executable xsvariable `xs`
   type `['e]` ysvariable `ys`
   type `['e]`
  {-# inline isSubsetOfconstant `Prelude.Collection.isSubsetOf`
   constant of type-class instance `Eq 'e => CollectionWithSubsetTest (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable #-}

  define isProperSubsetOfconstant `Prelude.Collection.isProperSubsetOf`
   constant of type-class instance `Eq 'e => CollectionWithSubsetTest (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable xsvariable `xs`
   type `['e]`) (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable ysvariable `ys`
   type `['e]`) := listSubsetOfconstant `Data.Collection.ListBag.listSubsetOf`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   type in context `['e] -> ['e] -> Bool`
   executable xsvariable `xs`
   type `['e]` ysvariable `ys`
   type `['e]` &&constant `Prelude.Bool.(&&)`
   constant
   type `Bool -> Bool -> Bool`
   executable (lengthconstant `Prelude.List.length`
   constant
   type `['a] -> Natural`
   type in context `['e] -> Natural`
   executable xsvariable `xs`
   type `['e]` <constant `Prelude.Ord.(<)`
   constant of type-class `Ord`
   type `'a -> 'a -> Bool`
   type in context `Natural -> Natural -> Bool`
   executable
   statically resolved type-class instance lengthconstant `Prelude.List.length`
   constant
   type `['a] -> Natural`
   type in context `['e] -> Natural`
   executable ysvariable `ys`
   type `['e]`)
  {-# inline isProperSubsetOfconstant `Prelude.Collection.isProperSubsetOf`
   constant of type-class instance `Eq 'e => CollectionWithSubsetTest (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable #-}

  define isSetEquivconstant `Prelude.Collection.isSetEquiv`
   constant of type-class instance `Eq 'e => CollectionWithSubsetTest (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable xsvariable `xs`
   type `['e]`) (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable ysvariable `ys`
   type `['e]`) := listSetEquivconstant `Data.Collection.ListBag.listSetEquiv`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   type in context `['e] -> ['e] -> Bool`
   executable xsvariable `xs`
   type `['e]` ysvariable `ys`
   type `['e]`
  {-# inline isSetEquivconstant `Prelude.Collection.isSetEquiv`
   constant of type-class instance `Eq 'e => CollectionWithSubsetTest (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable #-}

  define disjointconstant `Prelude.Collection.disjoint`
   constant of type-class instance `Eq 'e => CollectionWithSubsetTest (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable xsvariable `xs`
   type `['e]`) (ListBagconstant `Data.Collection.ListBag.ListBag`
   constructor of datatype `ListBag`
   type `['a] -> ListBag 'a`
   type in context `['e] -> ListBag 'e`
   executable ysvariable `ys`
   type `['e]`) := listDisjointconstant `Data.Collection.ListBag.listDisjoint`
   constant
   type `Eq 'a => ['a] -> ['a] -> Bool`
   type in context `['e] -> ['e] -> Bool`
   executable xsvariable `xs`
   type `['e]` ysvariable `ys`
   type `['e]`
  {-# inline disjointconstant `Prelude.Collection.disjoint`
   constant of type-class instance `Eq 'e => CollectionWithSubsetTest (ListBag 'e) 'e`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable #-}
end-instance

instance Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - full (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) where
  define non-exec (===)constant `Prelude.Eq.(===)`
   constant of type-class instance `Eq 'e => EqP (ListBag 'e)`
   type `ListBag 'e -> ListBag 'e -> Prop`
   non-executable q1variable `q1`
   type `ListBag 'e` q2variable `q2`
   type `ListBag 'e` := bool2propconstant `Prelude.Bool.bool2prop`
   constant
   type `Bool -> Prop`
   non-executable (isSetEquivconstant `Prelude.Collection.isSetEquiv`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   type in context `ListBag 'e -> ListBag 'e -> Bool`
   executable
   statically resolved type-class instance q1variable `q1`
   type `ListBag 'e` q2variable `q2`
   type `ListBag 'e`)
end-instance

instance Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) where
  define (==)constant `Prelude.Eq.(==)`
   constant of type-class instance `Eq 'e => Eq (ListBag 'e)`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable := isSetEquivconstant `Prelude.Collection.isSetEquiv`
   constant of type-class `CollectionWithSubsetTest`
   type `'c -> 'c -> Bool`
   type in context `ListBag 'e -> ListBag 'e -> Bool`
   executable
   statically resolved type-class instance
  {-# inline (==)constant `Prelude.Eq.(==)`
   constant of type-class instance `Eq 'e => Eq (ListBag 'e)`
   type `ListBag 'e -> ListBag 'e -> Bool`
   executable #-}
end-instance

instance BagLiketype-class `Prelude.Collection.BagLike`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.CollectionWithMembershipTest 'c 'e (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
end-instance

instance Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => 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 (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
end-instance

instance Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'etype-variable `'e`
   kind `*` => 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 (ListBagdatatype `Data.Collection.ListBag.ListBag`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
end-instance

end-moduleend of module Data.Collection.ListBag