Classes

   B      C      D      E      F      I      L      M      N      O      S   

• Bag
  • Prelude.Bag (alias for Prelude.Collection.Bag)
  • Prelude.Collection.Bag
    • arguments: 'c, 'e
    • super-classes:
      • BagLike 'c 'e
      • CollectionWithDelete 'c 'e
      • CollectionWithEmptynessTest 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      Eq 'e =>

      Bag

      (Data.Collection.ListBag.ListBag 'e)

      'e

• BagLike
  • Prelude.BagLike (alias for Prelude.Collection.BagLike)
  • Prelude.Collection.BagLike
    • arguments: 'c, 'e
    • super-classes:
      • CollectionWithMembershipTest 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      BagLike

      (Data.Collection.ListBag.ListBag 'e)

      'e

• Bounded
  • Prelude.Bounded (alias for Prelude.BasicClasses.Bounded)
  • Prelude.BasicClasses.Bounded
    • arguments: 'a
    • super-classes:
      • Ord 'a
    • functional-dependencies: -
    • instances:

      		Bounded	Bool
      		Bounded	Ordering

• Collection
  • Prelude.Collection (alias for Prelude.Collection.Collection)
  • Prelude.Collection.Collection
    • arguments: 'c, 'e
    • super-classes:
      • Monoid 'c
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      	Eq 'e =>	Collection	(Data.Collection.DistinctListSet.DistinctListSet 'e)	'e
      	Eq 'e =>	Collection	(Data.Collection.FunSetBool.FunSetBool 'e)	'e
      		Collection	(Data.Collection.ListBag.ListBag 'e)	'e
      		Collection	(Data.Collection.Queue.Queue 'e)	'e
      		Collection	(Data.Collection.Stack.Stack 'e)	'e
      		Collection	['e]	'e

• CollectionWithDelete
  • Prelude.CollectionWithDelete (alias for Prelude.Collection.CollectionWithDelete)
  • Prelude.Collection.CollectionWithDelete
    • arguments: 'c, 'e
    • super-classes:
      • Eq 'e
      • CollectionWithMembershipTest 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      	Eq 'e =>	CollectionWithDelete	(Data.Collection.DistinctListSet.DistinctListSet 'e)	'e
      	Eq 'e =>	CollectionWithDelete	(Data.Collection.FunSetBool.FunSetBool 'e)	'e
      	Eq 'e =>	CollectionWithDelete	(Data.Collection.ListBag.ListBag 'e)	'e
      	Eq 'e =>	CollectionWithDelete	['e]	'e

• CollectionWithEmptynessTest
  • Prelude.CollectionWithEmptynessTest (alias for Prelude.Collection.CollectionWithEmptynessTest)
  • Prelude.Collection.CollectionWithEmptynessTest
    • arguments: 'c, 'e
    • super-classes:
      • Collection 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      	Eq 'e =>	CollectionWithEmptynessTest	(Data.Collection.DistinctListSet.DistinctListSet 'e)	'e
      		CollectionWithEmptynessTest	(Data.Collection.ListBag.ListBag 'e)	'e
      		CollectionWithEmptynessTest	(Data.Collection.Queue.Queue 'e)	'e
      		CollectionWithEmptynessTest	(Data.Collection.Stack.Stack 'e)	'e
      		CollectionWithEmptynessTest	['e]	'e

• CollectionWithMembershipTest
  • Prelude.CollectionWithMembershipTest (alias for Prelude.Collection.CollectionWithMembershipTest)
  • Prelude.Collection.CollectionWithMembershipTest
    • arguments: 'c, 'e
    • super-classes:
      • Collection 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      	Eq 'e =>	CollectionWithMembershipTest	(Data.Collection.DistinctListSet.DistinctListSet 'e)	'e
      	Eq 'e =>	CollectionWithMembershipTest	(Data.Collection.FunSetBool.FunSetBool 'e)	'e
      		CollectionWithMembershipTest	(Data.Collection.ListBag.ListBag 'e)	'e
      	Eq 'e =>	CollectionWithMembershipTest	(Data.Collection.Queue.Queue 'e)	'e
      	Eq 'e =>	CollectionWithMembershipTest	(Data.Collection.Stack.Stack 'e)	'e
      		CollectionWithMembershipTest	['e]	'e

• CollectionWithSubsetTest
  • Prelude.CollectionWithSubsetTest (alias for Prelude.Collection.CollectionWithSubsetTest)
  • Prelude.Collection.CollectionWithSubsetTest
    • arguments: 'c, 'e
    • super-classes:
      • CollectionWithDelete 'c 'e
      • CollectionWithEmptynessTest 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      	Eq 'e =>	CollectionWithSubsetTest	(Data.Collection.DistinctListSet.DistinctListSet 'e)	'e
      	Eq 'e =>	CollectionWithSubsetTest	(Data.Collection.ListBag.ListBag 'e)	'e

• Default
  • Prelude.Default (alias for Prelude.Default.Default)
  • Prelude.Default.Default
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      		Default	Bool
      		Default	Char
      		Default	(Maybe 'a)
      		Default	Natural
      		Default	Ordering
      		Default	['a]

• Dot
  • Prelude.Dot (alias for Prelude.Function.Dot)
  • Prelude.Function.Dot
    • arguments: 'a, 'b, 'c
    • super-classes: -
    • functional-dependencies:
      • 'a, 'b -> 'c
    • instances:

      		Dot	('b -> 'c)	('a -> 'b2)	('a -> 'c)	| 'b2 -> 'b
      		Dot	(Data.Lens.Getter 'a 'b)	(Data.Lens.Getter 'b2 'c)	(Data.Lens.Getter 'a 'c)	| 'b2 -> 'b
      		Dot	(Data.Lens.Getter 'a 'b)	(Data.Lens.Lens 'b2 'x 'c 'y)	(Data.Lens.Getter 'a 'c)	| 'b2 -> 'b
      		Dot	(Data.Lens.Lens 'a 'x 'b 'y)	(Data.Lens.Getter 'b2 'c)	(Data.Lens.Getter 'a 'c)	| 'b2 -> 'b
      		Dot	(Data.Lens.Lens 's1 't1 'a1 'b1)	(Data.Lens.Lens 's2 't2 'a2 'b2)	(Data.Lens.Lens 's1 't1 'a2 'b2)	| 'a1 -> 's2, 'b1 -> 't2
      		Dot	(Data.Lens.Lens 's1 't1 'a1 'b1)	(Data.Lens.Setter 's2 't2 'b2)	(Data.Lens.Setter 's1 't1 'b2)	| 'a1 -> 's2, 'b1 -> 't2

• Elem1
  • Data.Lens.Elem1
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      		Data.Lens.Elem1	('a1, 'a2)	'x	'z	'y	| 'x -> ('y, 'a2), 'z -> 'a1
      		Data.Lens.Elem1	('a1, 'a2, 'a3)	'x	'z	'y	| 'x -> ('y, 'a2, 'a3), 'z -> 'a1
      		Data.Lens.Elem1	('a1, 'a2, 'a3, 'a4)	'x	'z	'y	| 'x -> ('y, 'a2, 'a3, 'a4), 'z -> 'a1
      		Data.Lens.Elem1	('a1, 'a2, 'a3, 'a4, 'a5)	'x	'z	'y	| 'x -> ('y, 'a2, 'a3, 'a4, 'a5), 'z -> 'a1
      		Data.Lens.Elem1	('a1, 'a2, 'a3, 'a4, 'a5, 'a6)	'x	'z	'y	| 'x -> ('y, 'a2, 'a3, 'a4, 'a5, 'a6), 'z -> 'a1
      		Data.Lens.Elem1	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7)	'x	'z	'y	| 'x -> ('y, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7), 'z -> 'a1
      		Data.Lens.Elem1	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8)	'x	'z	'y	| 'x -> ('y, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8), 'z -> 'a1
      		Data.Lens.Elem1	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)	'x	'z	'y	| 'x -> ('y, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9), 'z -> 'a1

• Elem2
  • Data.Lens.Elem2
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      		Data.Lens.Elem2	('a1, 'a2)	'x	'z	'y	| 'x -> ('a1, 'y), 'z -> 'a2
      		Data.Lens.Elem2	('a1, 'a2, 'a3)	'x	'z	'y	| 'x -> ('a1, 'y, 'a3), 'z -> 'a2
      		Data.Lens.Elem2	('a1, 'a2, 'a3, 'a4)	'x	'z	'y	| 'x -> ('a1, 'y, 'a3, 'a4), 'z -> 'a2
      		Data.Lens.Elem2	('a1, 'a2, 'a3, 'a4, 'a5)	'x	'z	'y	| 'x -> ('a1, 'y, 'a3, 'a4, 'a5), 'z -> 'a2
      		Data.Lens.Elem2	('a1, 'a2, 'a3, 'a4, 'a5, 'a6)	'x	'z	'y	| 'x -> ('a1, 'y, 'a3, 'a4, 'a5, 'a6), 'z -> 'a2
      		Data.Lens.Elem2	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7)	'x	'z	'y	| 'x -> ('a1, 'y, 'a3, 'a4, 'a5, 'a6, 'a7), 'z -> 'a2
      		Data.Lens.Elem2	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8)	'x	'z	'y	| 'x -> ('a1, 'y, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8), 'z -> 'a2
      		Data.Lens.Elem2	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)	'x	'z	'y	| 'x -> ('a1, 'y, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9), 'z -> 'a2

• Elem3
  • Data.Lens.Elem3
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      		Data.Lens.Elem3	('a1, 'a2, 'a3)	'x	'z	'y	| 'x -> ('a1, 'a2, 'y), 'z -> 'a3
      		Data.Lens.Elem3	('a1, 'a2, 'a3, 'a4)	'x	'z	'y	| 'x -> ('a1, 'a2, 'y, 'a4), 'z -> 'a3
      		Data.Lens.Elem3	('a1, 'a2, 'a3, 'a4, 'a5)	'x	'z	'y	| 'x -> ('a1, 'a2, 'y, 'a4, 'a5), 'z -> 'a3
      		Data.Lens.Elem3	('a1, 'a2, 'a3, 'a4, 'a5, 'a6)	'x	'z	'y	| 'x -> ('a1, 'a2, 'y, 'a4, 'a5, 'a6), 'z -> 'a3
      		Data.Lens.Elem3	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7)	'x	'z	'y	| 'x -> ('a1, 'a2, 'y, 'a4, 'a5, 'a6, 'a7), 'z -> 'a3
      		Data.Lens.Elem3	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8)	'x	'z	'y	| 'x -> ('a1, 'a2, 'y, 'a4, 'a5, 'a6, 'a7, 'a8), 'z -> 'a3
      		Data.Lens.Elem3	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)	'x	'z	'y	| 'x -> ('a1, 'a2, 'y, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9), 'z -> 'a3

• Elem4
  • Data.Lens.Elem4
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      		Data.Lens.Elem4	('a1, 'a2, 'a3, 'a4)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'y), 'z -> 'a4
      		Data.Lens.Elem4	('a1, 'a2, 'a3, 'a4, 'a5)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'y, 'a5), 'z -> 'a4
      		Data.Lens.Elem4	('a1, 'a2, 'a3, 'a4, 'a5, 'a6)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'y, 'a5, 'a6), 'z -> 'a4
      		Data.Lens.Elem4	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'y, 'a5, 'a6, 'a7), 'z -> 'a4
      		Data.Lens.Elem4	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'y, 'a5, 'a6, 'a7, 'a8), 'z -> 'a4
      		Data.Lens.Elem4	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'y, 'a5, 'a6, 'a7, 'a8, 'a9), 'z -> 'a4

• Elem5
  • Data.Lens.Elem5
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      		Data.Lens.Elem5	('a1, 'a2, 'a3, 'a4, 'a5)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'y), 'z -> 'a5
      		Data.Lens.Elem5	('a1, 'a2, 'a3, 'a4, 'a5, 'a6)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'y, 'a6), 'z -> 'a5
      		Data.Lens.Elem5	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'y, 'a6, 'a7), 'z -> 'a5
      		Data.Lens.Elem5	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'y, 'a6, 'a7, 'a8), 'z -> 'a5
      		Data.Lens.Elem5	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'y, 'a6, 'a7, 'a8, 'a9), 'z -> 'a5

• Elem6
  • Data.Lens.Elem6
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      		Data.Lens.Elem6	('a1, 'a2, 'a3, 'a4, 'a5, 'a6)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'y), 'z -> 'a6
      		Data.Lens.Elem6	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'y, 'a7), 'z -> 'a6
      		Data.Lens.Elem6	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'y, 'a7, 'a8), 'z -> 'a6
      		Data.Lens.Elem6	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'y, 'a7, 'a8, 'a9), 'z -> 'a6

• Elem7
  • Data.Lens.Elem7
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      		Data.Lens.Elem7	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'y), 'z -> 'a7
      		Data.Lens.Elem7	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'y, 'a8), 'z -> 'a7
      		Data.Lens.Elem7	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'y, 'a8, 'a9), 'z -> 'a7

• Elem8
  • Data.Lens.Elem8
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      		Data.Lens.Elem8	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'y), 'z -> 'a8
      		Data.Lens.Elem8	('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)	'x	'z	'y	| 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'y, 'a9), 'z -> 'a8

• Elem9
  • Data.Lens.Elem9
    • arguments: 's, 't, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 's -> 'a
      • 's, 'b -> 't
    • instances:

      Data.Lens.Elem9

      ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9)

      'x

      'z

      'y

      | 'x -> ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'y), 'z -> 'a9

• Enum
  • Prelude.Enum (alias for Prelude.BasicClasses.Enum)
  • Prelude.BasicClasses.Enum
    • arguments: 'a
    • super-classes:
      • Ord 'a
    • functional-dependencies: -
    • instances:

      		Enum	Bool
      		Enum	Char
      		Enum	Natural
      		Enum	Ordering

• Eq
  • Prelude.Eq (alias for Prelude.Eq.Eq)
  • Prelude.Eq.Eq
    • arguments: 'a
    • super-classes:
      • EqP 'a
    • functional-dependencies: -
    • instances:

      	(Eq 'a, Eq 'b) =>	Eq	('a, 'b)
      	(Eq 'a, Eq 'b, Eq 'c) =>	Eq	('a, 'b, 'c)
      	(Eq 'a, Eq 'b, Eq 'c, Eq 'd) =>	Eq	('a, 'b, 'c, 'd)
      	(Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e) =>	Eq	('a, 'b, 'c, 'd, 'e)
      	(Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e, Eq 'f) =>	Eq	('a, 'b, 'c, 'd, 'e, 'f)
      	(Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e, Eq 'f, Eq 'g) =>	Eq	('a, 'b, 'c, 'd, 'e, 'f, 'g)
      	(Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e, Eq 'f, Eq 'g, Eq 'h) =>	Eq	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h)
      	(Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e, Eq 'f, Eq 'g, Eq 'h, Eq 'i) =>	Eq	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i)
      		Eq	()
      		Eq	Bool
      		Eq	BuiltInChar
      		Eq	BuiltInDecimal
      		Eq	BuiltInNum
      		Eq	BuiltInString
      		Eq	Char
      	Eq 'e =>	Eq	(Data.Collection.ListBag.ListBag 'e)
      	Eq 'a =>	Eq	(Data.Collection.Queue.Queue 'a)
      	Eq 'a =>	Eq	(Data.Collection.Stack.Stack 'a)
      	(Eq 'a, Eq 'b) =>	Eq	(Either 'a 'b)
      	Eq 'a =>	Eq	(Maybe 'a)
      		Eq	Natural
      		Eq	Ordering
      		Eq	Text
      	Eq 'a =>	Eq	['a]

• EqP
  • Prelude.EqP (alias for Prelude.Eq.EqP)
  • Prelude.Eq.EqP
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      	EqP 'b =>	EqP	('a -> 'b)
      	(EqP 'a, EqP 'b) =>	EqP	('a, 'b)
      	(EqP 'a, EqP 'b, EqP 'c) =>	EqP	('a, 'b, 'c)
      	(EqP 'a, EqP 'b, EqP 'c, EqP 'd) =>	EqP	('a, 'b, 'c, 'd)
      	(EqP 'a, EqP 'b, EqP 'c, EqP 'd, EqP 'e) =>	EqP	('a, 'b, 'c, 'd, 'e)
      	(EqP 'a, EqP 'b, EqP 'c, EqP 'd, EqP 'e, EqP 'f) =>	EqP	('a, 'b, 'c, 'd, 'e, 'f)
      	(EqP 'a, EqP 'b, EqP 'c, EqP 'd, EqP 'e, EqP 'f, EqP 'g) =>	EqP	('a, 'b, 'c, 'd, 'e, 'f, 'g)
      	(EqP 'a, EqP 'b, EqP 'c, EqP 'd, EqP 'e, EqP 'f, EqP 'g, EqP 'h) =>	EqP	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h)
      	(EqP 'a, EqP 'b, EqP 'c, EqP 'd, EqP 'e, EqP 'f, EqP 'g, EqP 'h, EqP 'i) =>	EqP	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i)
      		EqP	()
      		EqP	Bool
      		EqP	BuiltInChar
      		EqP	BuiltInDecimal
      		EqP	BuiltInNum
      		EqP	BuiltInString
      		EqP	Char
      	Eq 'e =>	EqP	(Data.Collection.ListBag.ListBag 'e)
      	EqP 'a =>	EqP	(Data.Collection.Queue.Queue 'a)
      	EqP 'a =>	EqP	(Data.Collection.Stack.Stack 'a)
      	(EqP 'a, EqP 'b) =>	EqP	(Either 'a 'b)
      	EqP 'a =>	EqP	(Maybe 'a)
      		EqP	Natural
      		EqP	Ordering
      		EqP	Text
      	EqP 'a =>	EqP	['a]

• Finite
  • Prelude.Finite (alias for Prelude.BasicClasses.Finite)
  • Prelude.BasicClasses.Finite
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      	(!Finite 'a, !Finite 'b) =>	Finite	('a, 'b)
      	(!Finite 'a, !Finite 'b, !Finite 'c) =>	Finite	('a, 'b, 'c)
      	(!Finite 'a, !Finite 'b, !Finite 'c, !Finite 'd) =>	Finite	('a, 'b, 'c, 'd)
      	(!Finite 'a, !Finite 'b, !Finite 'c, !Finite 'd, !Finite 'e) =>	Finite	('a, 'b, 'c, 'd, 'e)
      	(!Finite 'a, !Finite 'b, !Finite 'c, !Finite 'd, !Finite 'e, !Finite 'f) =>	Finite	('a, 'b, 'c, 'd, 'e, 'f)
      	(!Finite 'a, !Finite 'b, !Finite 'c, !Finite 'd, !Finite 'e, !Finite 'f, !Finite 'g) =>	Finite	('a, 'b, 'c, 'd, 'e, 'f, 'g)
      	(!Finite 'a, !Finite 'b, !Finite 'c, !Finite 'd, !Finite 'e, !Finite 'f, !Finite 'g, !Finite 'h) =>	Finite	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h)
      	(!Finite 'a, !Finite 'b, !Finite 'c, !Finite 'd, !Finite 'e, !Finite 'f, !Finite 'g, !Finite 'h, !Finite 'i) =>	Finite	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i)
      	(!Finite 'a, !Finite 'b, !Finite 'c, !Finite 'd, !Finite 'e, !Finite 'f, !Finite 'g, !Finite 'h, !Finite 'i, !Finite 'j) =>	Finite	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j)
      		Finite	()
      		Finite	Bool
      	(!Finite 'a, !Finite 'b) =>	Finite	(Either 'a 'b)
      	!Finite 'a =>	Finite	(Maybe 'a)
      		Finite	Ordering

• FiniteBag
  • Prelude.FiniteBag (alias for Prelude.Collection.FiniteBag)
  • Prelude.Collection.FiniteBag
    • arguments: 'c, 'e
    • super-classes:
      • Bag 'c 'e
      • FiniteCollection 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      Eq 'e =>

      FiniteBag

      (Data.Collection.ListBag.ListBag 'e)

      'e

• FiniteCollection
  • Prelude.FiniteCollection (alias for Prelude.Collection.FiniteCollection)
  • Prelude.Collection.FiniteCollection
    • arguments: 'c, 'e
    • super-classes:
      • CollectionWithMembershipTest 'c 'e
      • Foldable 'c 'e
      • CollectionWithEmptynessTest 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      	Eq 'e =>	FiniteCollection	(Data.Collection.DistinctListSet.DistinctListSet 'e)	'e
      	Eq 'e =>	FiniteCollection	(Data.Collection.ListBag.ListBag 'e)	'e
      	Eq 'e =>	FiniteCollection	(Data.Collection.Queue.Queue 'e)	'e
      	Eq 'e =>	FiniteCollection	(Data.Collection.Stack.Stack 'e)	'e
      		FiniteCollection	['e]	'e

• FiniteSet
  • Prelude.FiniteSet (alias for Prelude.Collection.FiniteSet)
  • Prelude.Collection.FiniteSet
    • arguments: 'c, 'e
    • super-classes:
      • Set 'c 'e
      • FiniteCollection 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      Eq 'e =>

      FiniteSet

      (Data.Collection.DistinctListSet.DistinctListSet 'e)

      'e

• Foldable
  • Prelude.Foldable (alias for Prelude.Foldable.Foldable)
  • Prelude.Foldable.Foldable
    • arguments: 't, 'e
    • super-classes: -
    • functional-dependencies:
      • 't -> 'e
    • instances:

      		Foldable	('a, 'a)	'a
      		Foldable	('a, 'a, 'a)	'a
      		Foldable	('a, 'a, 'a, 'a)	'a
      		Foldable	('a, 'a, 'a, 'a, 'a)	'a
      		Foldable	('a, 'a, 'a, 'a, 'a, 'a)	'a
      		Foldable	('a, 'a, 'a, 'a, 'a, 'a, 'a)	'a
      		Foldable	('a, 'a, 'a, 'a, 'a, 'a, 'a, 'a)	'a
      		Foldable	(Data.Collection.DistinctListSet.DistinctListSet 'e)	'e
      		Foldable	(Data.Collection.ListBag.ListBag 'e)	'e
      		Foldable	(Data.Collection.Queue.Queue 'e)	'e
      		Foldable	(Data.Collection.Stack.Stack 'e)	'e
      		Foldable	(Maybe 'a)	'a
      		Foldable	['a]	'a

• Functor
  • Prelude.Functor (alias for Prelude.Functor.Functor)
  • Prelude.Functor.Functor
    • arguments: 'F
    • super-classes: -
    • functional-dependencies: -
    • instances:

      		Functor	Data.Collection.ListBag.ListBag
      		Functor	Data.Collection.Queue.Queue
      		Functor	Data.Collection.Stack.Stack
      		Functor	List
      		Functor	Maybe
      		Functor	Tuple2
      		Functor	Tuple3
      		Functor	Tuple4
      		Functor	Tuple5
      		Functor	Tuple6
      		Functor	Tuple7
      		Functor	Tuple8
      		Functor	Tuple9

• IsGetter
  • Data.Lens.IsGetter
    • arguments: 'v, 'a, 'b
    • super-classes: -
    • functional-dependencies:
      • 'v -> 'a, 'b
    • instances:

      		Data.Lens.IsGetter	(Data.Lens.Getter 'a 'b)	'a	'b
      		Data.Lens.IsGetter	(Data.Lens.Lens 's 't 'a 'b)	's	'a

• IsSetter
  • Data.Lens.IsSetter
    • arguments: 'v, 's, 't, 'b
    • super-classes: -
    • functional-dependencies:
      • 'v -> 's, 't, 'b
    • instances:

      		Data.Lens.IsSetter	(Data.Lens.Lens 's 't 'a 'b)	's	't	'b
      		Data.Lens.IsSetter	(Data.Lens.Setter 's 't 'b)	's	't	'b

• LiteralChar
  • Prelude.LiteralChar (alias for Prelude.Literal.LiteralChar)
  • Prelude.Literal.LiteralChar
    • arguments: 'a
    • super-classes:
      • Eq 'a
    • functional-dependencies: -
    • instances:

      		LiteralChar	BuiltInChar
      		LiteralChar	Char

• LiteralDecimal
  • Prelude.LiteralDecimal (alias for Prelude.Literal.LiteralDecimal)
  • Prelude.Literal.LiteralDecimal
    • arguments: 'a
    • super-classes:
      • LiteralNum 'a
    • functional-dependencies: -
    • instances:

      LiteralDecimal

      BuiltInDecimal

• LiteralNum
  • Prelude.LiteralNum (alias for Prelude.Literal.LiteralNum)
  • Prelude.Literal.LiteralNum
    • arguments: 'a
    • super-classes:
      • Eq 'a
    • functional-dependencies: -
    • instances:

      		LiteralNum	Bool
      		LiteralNum	BuiltInDecimal
      		LiteralNum	BuiltInNum
      		LiteralNum	Natural

• LiteralString
  • Prelude.LiteralString (alias for Prelude.Literal.LiteralString)
  • Prelude.Literal.LiteralString
    • arguments: 'a
    • super-classes:
      • Eq 'a
    • functional-dependencies: -
    • instances:

      		LiteralString	BuiltInString
      		LiteralString	String
      		LiteralString	Text

• Monad
  • Prelude.Monad (alias for Prelude.Monad.Monad)
  • Prelude.Monad.Monad
    • arguments: 'M
    • super-classes: -
    • functional-dependencies: -
    • instances:

      		Monad	List
      		Monad	Maybe

• MonadFail
  • Prelude.MonadFail (alias for Prelude.Monad.MonadFail)
  • Prelude.Monad.MonadFail
    • arguments: 'M
    • super-classes:
      • !Monad 'M
    • functional-dependencies: -
    • instances:

      MonadFail

      Maybe

• Monoid
  • Prelude.Monoid (alias for Prelude.BasicClasses.Monoid)
  • Prelude.BasicClasses.Monoid
    • arguments: 'a
    • super-classes:
      • Semigroup 'a
    • functional-dependencies: -
    • instances:

      		Monoid	()
      	Eq 'e =>	Monoid	(Data.Collection.DistinctListSet.DistinctListSet 'e)
      	Eq 'e =>	Monoid	(Data.Collection.FunSetBool.FunSetBool 'e)
      		Monoid	(Data.Collection.ListBag.ListBag 'a)
      		Monoid	(Data.Collection.Queue.Queue 'a)
      		Monoid	(Data.Collection.Stack.Stack 'a)
      		Monoid	Ordering
      		Monoid	Text
      		Monoid	['a]

• NumDiv
  • Prelude.NumDiv (alias for Prelude.Num.NumDiv)
  • Prelude.Num.NumDiv
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      NumDiv

      Natural

• NumDivMod
  • Prelude.NumDivMod (alias for Prelude.Num.NumDivMod)
  • Prelude.Num.NumDivMod
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      NumDivMod

      Natural

• NumMinus
  • Prelude.NumMinus (alias for Prelude.Num.NumMinus)
  • Prelude.Num.NumMinus
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      NumMinus

      Natural

• NumMult
  • Prelude.NumMult (alias for Prelude.Num.NumMult)
  • Prelude.Num.NumMult
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      NumMult

      Natural

• NumPlus
  • Prelude.NumPlus (alias for Prelude.Num.NumPlus)
  • Prelude.Num.NumPlus
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      NumPlus

      Natural

• Ord
  • Prelude.Ord (alias for Prelude.Ord.Ord)
  • Prelude.Ord.Ord
    • arguments: 'a
    • super-classes:
      • Eq 'a
    • functional-dependencies: -
    • instances:

      	(Ord 'a, Ord 'b) =>	Ord	('a, 'b)
      	(Ord 'a, Ord 'b, Ord 'c) =>	Ord	('a, 'b, 'c)
      	(Ord 'a, Ord 'b, Ord 'c, Ord 'd) =>	Ord	('a, 'b, 'c, 'd)
      	(Ord 'a, Ord 'b, Ord 'c, Ord 'd, Ord 'e) =>	Ord	('a, 'b, 'c, 'd, 'e)
      	(Ord 'a, Ord 'b, Ord 'c, Ord 'd, Ord 'e, Ord 'f) =>	Ord	('a, 'b, 'c, 'd, 'e, 'f)
      	(Ord 'a, Ord 'b, Ord 'c, Ord 'd, Ord 'e, Ord 'f, Ord 'g) =>	Ord	('a, 'b, 'c, 'd, 'e, 'f, 'g)
      	(Ord 'a, Ord 'b, Ord 'c, Ord 'd, Ord 'e, Ord 'f, Ord 'g, Ord 'h) =>	Ord	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h)
      	(Ord 'a, Ord 'b, Ord 'c, Ord 'd, Ord 'e, Ord 'f, Ord 'g, Ord 'h, Ord 'i) =>	Ord	('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i)
      		Ord	()
      		Ord	Bool
      		Ord	Char
      	Ord 'a =>	Ord	(Data.Collection.Queue.Queue 'a)
      	Ord 'a =>	Ord	(Data.Collection.Stack.Stack 'a)
      	(Ord 'a, Ord 'b) =>	Ord	(Either 'a 'b)
      	Ord 'a =>	Ord	(Maybe 'a)
      		Ord	Natural
      		Ord	Ordering
      		Ord	Text
      	Ord 'a =>	Ord	['a]

• Semigroup
  • Prelude.Semigroup (alias for Prelude.BasicClasses.Semigroup)
  • Prelude.BasicClasses.Semigroup
    • arguments: 'a
    • super-classes: -
    • functional-dependencies: -
    • instances:

      		Semigroup	()
      	Eq 'e =>	Semigroup	(Data.Collection.DistinctListSet.DistinctListSet 'e)
      	Eq 'e =>	Semigroup	(Data.Collection.FunSetBool.FunSetBool 'e)
      		Semigroup	(Data.Collection.ListBag.ListBag 'a)
      		Semigroup	(Data.Collection.Queue.Queue 'a)
      		Semigroup	(Data.Collection.Stack.Stack 'a)
      		Semigroup	Ordering
      		Semigroup	Text
      		Semigroup	['a]

• Set
  • Prelude.Set (alias for Prelude.Collection.Set)
  • Prelude.Collection.Set
    • arguments: 'c, 'e
    • super-classes:
      • SetLike 'c 'e
      • CollectionWithDelete 'c 'e
      • CollectionWithEmptynessTest 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      Eq 'e =>

      Set

      (Data.Collection.DistinctListSet.DistinctListSet 'e)

      'e

• SetLike
  • Prelude.SetLike (alias for Prelude.Collection.SetLike)
  • Prelude.Collection.SetLike
    • arguments: 'c, 'e
    • super-classes:
      • CollectionWithMembershipTest 'c 'e
    • functional-dependencies:
      • 'c -> 'e
    • instances:

      	Eq 'e =>	SetLike	(Data.Collection.DistinctListSet.DistinctListSet 'e)	'e
      	Eq 'e =>	SetLike	(Data.Collection.FunSetBool.FunSetBool 'e)	'e