Data/Collection/Queue.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



module Data.Collection.Queue (
  Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable,
  emptyQueueconstant `Data.Collection.Queue.emptyQueue`
   constant
   type `Queue 'a`
   executable,
  enqueueconstant `Data.Collection.Queue.enqueue`
   constant
   type `'a -> Queue 'a -> Queue 'a`
   executable,
  dequeueconstant `Data.Collection.Queue.dequeue`
   constant
   type `Queue 'a -> Maybe ('a, Queue 'a)`
   executable
) where 

import qualified Data.List as List

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

declare emptyQueueconstant `Data.Collection.Queue.emptyQueue`
   constant
   type `Queue 'a`
   executable :: Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`
define emptyQueueconstant `Data.Collection.Queue.emptyQueue`
   constant
   type `Queue 'a`
   executable := Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable [] []

{-# allow-similar-names "enqueue", "dequeue" #-}

declare enqueueconstant `Data.Collection.Queue.enqueue`
   constant
   type `'a -> Queue 'a -> Queue 'a`
   executable :: 'atype-variable `'a`
   kind `*` -> Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*` -> Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`
define enqueueconstant `Data.Collection.Queue.enqueue`
   constant
   type `'a -> Queue 'a -> Queue 'a`
   executable evariable `e`
   type `'a` (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable l1variable `l1`
   type `['a]` l2variable `l2`
   type `['a]`) := Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable l1variable `l1`
   type `['a]` (evariable `e`
   type `'a`:constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   executablel2variable `l2`
   type `['a]`)

declare dequeueconstant `Data.Collection.Queue.dequeue`
   constant
   type `Queue 'a -> Maybe ('a, Queue 'a)`
   executable :: Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*` -> Maybedatatype `Prelude.Maybe.Maybe`
   kind `* -> *`
   executable ('atype-variable `'a`
   kind `*`, Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`)
define rec dequeueconstant `Data.Collection.Queue.dequeue`
   constant
   type `Queue 'a -> Maybe ('a, Queue 'a)`
   executable (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable (evariable `e`
   type `'a`:constant `Prelude.List.(:)`
   constructor of datatype `List`
   type `'a -> ['a] -> ['a]`
   executablel1variable `l1`
   type `['a]`) l2variable `l2`
   type `['a]`) := Justconstant `Prelude.Maybe.Just`
   constructor of datatype `Maybe`
   type `'a -> Maybe 'a`
   type in context `('a, Queue 'a) -> Maybe ('a, Queue 'a)`
   executable (evariable `e`
   type `'a`, Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable l1variable `l1`
   type `['a]` l2variable `l2`
   type `['a]`)
         | dequeueconstant `Data.Collection.Queue.dequeue`
   constant
   type `Queue 'a -> Maybe ('a, Queue 'a)`
   executable (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable [] []) := Nothingconstant `Prelude.Maybe.Nothing`
   constructor of datatype `Maybe`
   type `Maybe 'a`
   type in context `Maybe ('a, Queue 'a)`
   executable 
         | dequeueconstant `Data.Collection.Queue.dequeue`
   constant
   type `Queue 'a -> Maybe ('a, Queue 'a)`
   executable (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable [] l2variable `l2`
   type `['a]`) := dequeueconstant `Data.Collection.Queue.dequeue` (recursive usage)
   constant
   type `Queue 'a -> Maybe ('a, Queue 'a)`
   executable (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable (reverseconstant `Prelude.List.reverse`
   constant
   type `['a] -> ['a]`
   executable l2variable `l2`
   type `['a]`) [])

declare queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable :: Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*` -> ['atype-variable `'a`
   kind `*`]
define queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable l1variable `l1`
   type `['a]` l2variable `l2`
   type `['a]`) := l1variable `l1`
   type `['a]` ++constant `Prelude.List.(++)`
   constant
   type `['a] -> ['a] -> ['a]`
   executable reverseconstant `Prelude.List.reverse`
   constant
   type `['a] -> ['a]`
   executable l2variable `l2`
   type `['a]`

declare queueFromListconstant `Data.Collection.Queue.queueFromList`
   constant
   type `['a] -> Queue 'a`
   executable :: ['atype-variable `'a`
   kind `*`] -> Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`
define queueFromListconstant `Data.Collection.Queue.queueFromList`
   constant
   type `['a] -> Queue 'a`
   executable lvariable `l`
   type `['a]` := Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   executable lvariable `l`
   type `['a]` []

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

instance EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - full 'atype-variable `'a`
   kind `*` => EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - full (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`) where 
  define non-exec (===)constant `Prelude.Eq.(===)`
   constant of type-class instance `EqP 'a => EqP (Queue 'a)`
   type `Queue 'a -> Queue 'a -> Prop`
   non-executable q1variable `q1`
   type `Queue 'a` q2variable `q2`
   type `Queue 'a` := (queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable q1variable `q1`
   type `Queue 'a`) ===constant `Prelude.Eq.(===)`
   constant of type-class `EqP`
   type `'a -> 'a -> Prop`
   type in context `['a] -> ['a] -> Prop`
   non-executable
   statically resolved type-class instance (queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable q2variable `q2`
   type `Queue 'a`)
end-instance

instance Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates 'atype-variable `'a`
   kind `*` => Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templates (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`) where 
  define (==)constant `Prelude.Eq.(==)`
   constant of type-class instance `Eq 'a => Eq (Queue 'a)`
   type `Queue 'a -> Queue 'a -> Bool`
   executable q1variable `q1`
   type `Queue 'a` q2variable `q2`
   type `Queue 'a` := (queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable q1variable `q1`
   type `Queue 'a`) ==constant `Prelude.Eq.(==)`
   constant of type-class `Eq`
   type `'a -> 'a -> Bool`
   type in context `['a] -> ['a] -> Bool`
   executable
   statically resolved type-class instance (queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable q2variable `q2`
   type `Queue 'a`)
end-instance

instance Ordtype-class `Prelude.Ord.Ord`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.Eq 'a
   has default derive templates 'atype-variable `'a`
   kind `*` => Ordtype-class `Prelude.Ord.Ord`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.Eq 'a
   has default derive templates (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`) where 
  define compareconstant `Prelude.Ord.compare`
   constant of type-class instance `Ord 'a => Ord (Queue 'a)`
   type `Queue 'a -> Queue 'a -> Ordering`
   executable q1variable `q1`
   type `Queue 'a` q2variable `q2`
   type `Queue 'a` := compareconstant `Prelude.Ord.compare`
   constant of type-class `Ord`
   type `'a -> 'a -> Ordering`
   type in context `['a] -> ['a] -> Ordering`
   executable
   statically resolved type-class instance (queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable q1variable `q1`
   type `Queue 'a`) (queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable q2variable `q2`
   type `Queue 'a`)
end-instance

instance Semigrouptype-class `Prelude.BasicClasses.Semigroup`
   arguments: ('a :: *) (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`) where 
  define (<>)constant `Prelude.BasicClasses.(<>)`
   constant of type-class instance `Semigroup (Queue 'a)`
   type `Queue 'a -> Queue 'a -> Queue 'a`
   executable q1variable `q1`
   type `Queue 'a` q2variable `q2`
   type `Queue 'a` := queueFromListconstant `Data.Collection.Queue.queueFromList`
   constant
   type `['a] -> Queue 'a`
   executable ((queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable q1variable `q1`
   type `Queue 'a`) ++constant `Prelude.List.(++)`
   constant
   type `['a] -> ['a] -> ['a]`
   executable (queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   executable q2variable `q2`
   type `Queue 'a`))
end-instance

instance Monoidtype-class `Prelude.BasicClasses.Monoid`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.BasicClasses.Semigroup 'a (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'atype-variable `'a`
   kind `*`) where 
  define memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class instance `Monoid (Queue 'a)`
   type `Queue 'a`
   executable := emptyQueueconstant `Data.Collection.Queue.emptyQueue`
   constant
   type `Queue 'a`
   executable
  {-# inline memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class instance `Monoid (Queue 'a)`
   type `Queue '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 (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define isEmptyconstant `Prelude.Collection.isEmpty`
   constant of type-class instance `CollectionWithEmptynessTest (Queue 'e) 'e`
   type `Queue 'e -> Bool`
   executable (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   type in context `['e] -> ['e] -> Queue 'e`
   executable l1variable `l1`
   type `['e]` l2variable `l2`
   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 l1variable `l1`
   type `['e]` &&constant `Prelude.Bool.(&&)`
   constant
   type `Bool -> Bool -> Bool`
   executable nullconstant `Prelude.Foldable.null`
   constant of type-class `Foldable`
   type `'t -> Bool`
   type in context `['e] -> Bool`
   executable
   statically resolved type-class instance l2variable `l2`
   type `['e]`)
end-instance

instance Collectiontype-class `Prelude.Collection.Collection`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.BasicClasses.Monoid 'c (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define insertconstant `Prelude.Collection.insert`
   constant of type-class instance `Collection (Queue 'e) 'e`
   type `'e -> Queue 'e -> Queue 'e`
   executable := enqueueconstant `Data.Collection.Queue.enqueue`
   constant
   type `'a -> Queue 'a -> Queue 'a`
   type in context `'e -> Queue 'e -> Queue 'e`
   executable
  {-# inline insertconstant `Prelude.Collection.insert`
   constant of type-class instance `Collection (Queue 'e) 'e`
   type `'e -> Queue 'e -> Queue 'e`
   executable #-}

  define fromListconstant `Prelude.Collection.fromList`
   constant of type-class instance `Collection (Queue 'e) 'e`
   type `['e] -> Queue 'e`
   executable := queueFromListconstant `Data.Collection.Queue.queueFromList`
   constant
   type `['a] -> Queue 'a`
   type in context `['e] -> Queue 'e`
   executable
  {-# inline fromListconstant `Prelude.Collection.fromList`
   constant of type-class instance `Collection (Queue 'e) 'e`
   type `['e] -> Queue 'e`
   executable #-}

  define non-exec isEmptyPconstant `Prelude.Collection.isEmptyP`
   constant of type-class instance `Collection (Queue 'e) 'e`
   type `Queue 'e -> Prop`
   non-executable qvariable `q`
   type `Queue 'e` := bool2propconstant `Prelude.Bool.bool2prop`
   constant
   type `Bool -> Prop`
   non-executable (isEmptyconstant `Prelude.Collection.isEmpty`
   constant of type-class `CollectionWithEmptynessTest`
   type `'c -> Bool`
   type in context `Queue 'e -> Bool`
   executable
   statically resolved type-class instance qvariable `q`
   type `Queue 'e`)
  define non-exec memberPconstant `Prelude.Collection.memberP`
   constant of type-class instance `Collection (Queue 'e) 'e`
   type `EqP 'e => 'e -> Queue 'e -> Prop`
   non-executable evariable `e`
   type `'e` (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   type in context `['e] -> ['e] -> Queue 'e`
   executable l1variable `l1`
   type `['e]` l2variable `l2`
   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` l1variable `l1`
   type `['e]` \/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` l2variable `l2`
   type `['e]`
end-instance

instance Foldabletype-class `Prelude.Foldable.Foldable`
   arguments: ('t :: *) ('e :: *)
   functional deps: 't -> 'e
   reserved var-names: 'acc (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable (Queue 'e) 'e`
   type `Queue 'e -> ['e]`
   executable := queueToListconstant `Data.Collection.Queue.queueToList`
   constant
   type `Queue 'a -> ['a]`
   type in context `Queue 'e -> ['e]`
   executable
  {-# inline toListconstant `Prelude.Foldable.toList`
   constant of type-class instance `Foldable (Queue 'e) 'e`
   type `Queue 'e -> ['e]`
   executable #-}

  define sizeconstant `Prelude.Foldable.size`
   constant of type-class instance `Foldable (Queue 'e) 'e`
   type `Queue 'e -> Natural`
   executable (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   type in context `['e] -> ['e] -> Queue 'e`
   executable l1variable `l1`
   type `['e]` l2variable `l2`
   type `['e]`) := lengthconstant `Prelude.List.length`
   constant
   type `['a] -> Natural`
   type in context `['e] -> Natural`
   executable l1variable `l1`
   type `['e]` +constant `Prelude.Num.(+)`
   constant of type-class `NumPlus`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance lengthconstant `Prelude.List.length`
   constant
   type `['a] -> Natural`
   type in context `['e] -> Natural`
   executable l2variable `l2`
   type `['e]`
  define nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable (Queue 'e) 'e`
   type `Queue 'e -> Bool`
   executable := isEmptyconstant `Prelude.Collection.isEmpty`
   constant of type-class `CollectionWithEmptynessTest`
   type `'c -> Bool`
   type in context `Queue 'e -> Bool`
   executable
   statically resolved type-class instance
  {-# inline nullconstant `Prelude.Foldable.null`
   constant of type-class instance `Foldable (Queue 'e) 'e`
   type `Queue 'e -> Bool`
   executable #-}

  define elemconstant `Prelude.Foldable.elem`
   constant of type-class instance `Foldable (Queue 'e) 'e`
   type `Eq 'e => 'e -> Queue 'e -> Bool`
   executable evariable `e`
   type `'e` (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   type in context `['e] -> ['e] -> Queue 'e`
   executable l1variable `l1`
   type `['e]` l2variable `l2`
   type `['e]`):= elemconstant `Prelude.Foldable.elem`
   constant of type-class `Foldable`
   type `Eq 'e => 'e -> 't -> Bool`
   type in context `'e -> ['e] -> Bool`
   executable
   statically resolved type-class instance evariable `e`
   type `'e` l1variable `l1`
   type `['e]` ||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 -> ['e] -> Bool`
   executable
   statically resolved type-class instance evariable `e`
   type `'e` l2variable `l2`
   type `['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 `*` => CollectionWithMembershipTesttype-class `Prelude.Collection.CollectionWithMembershipTest`
   arguments: ('c :: *) ('e :: *)
   functional deps: 'c -> 'e
   super-class constraints:
     - Prelude.Collection.Collection 'c 'e (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
  define occurconstant `Prelude.Collection.occur`
   constant of type-class instance `Eq 'e => CollectionWithMembershipTest (Queue 'e) 'e`
   type `Eq 'e => 'e -> Queue 'e -> Natural`
   executable evariable `e`
   type `'e` (Queueconstant `Data.Collection.Queue.Queue`
   constructor of datatype `Queue`
   type `['a] -> ['a] -> Queue 'a`
   type in context `['e] -> ['e] -> Queue 'e`
   executable l1variable `l1`
   type `['e]` l2variable `l2`
   type `['e]`) := countconstant `Prelude.List.count`
   constant
   type `Eq 'a => 'a -> ['a] -> Natural`
   type in context `'e -> ['e] -> Natural`
   executable evariable `e`
   type `'e` l1variable `l1`
   type `['e]` +constant `Prelude.Num.(+)`
   constant of type-class `NumPlus`
   type `'a -> 'a -> 'a`
   type in context `Natural -> Natural -> Natural`
   executable
   statically resolved type-class instance countconstant `Prelude.List.count`
   constant
   type `Eq 'a => 'a -> ['a] -> Natural`
   type in context `'e -> ['e] -> Natural`
   executable evariable `e`
   type `'e` l2variable `l2`
   type `['e]`
  define memberconstant `Prelude.Collection.member`
   constant of type-class instance `Eq 'e => CollectionWithMembershipTest (Queue 'e) 'e`
   type `Eq 'e => 'e -> Queue 'e -> Bool`
   executable := elemconstant `Prelude.Foldable.elem`
   constant of type-class `Foldable`
   type `Eq 'e => 'e -> 't -> Bool`
   type in context `'e -> Queue 'e -> Bool`
   executable
   statically resolved type-class instance
  {-# inline memberconstant `Prelude.Collection.member`
   constant of type-class instance `Eq 'e => CollectionWithMembershipTest (Queue 'e) 'e`
   type `Eq 'e => 'e -> Queue '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 (Queuedatatype `Data.Collection.Queue.Queue`
   kind `* -> *`
   executable 'etype-variable `'e`
   kind `*`) 'etype-variable `'e`
   kind `*` where
end-instance

end-moduleend of module Data.Collection.Queue