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
|
{-# LANGUAGE Haskell2010 #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ImpredicativeTypes #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
module Instances where
newtype (<~~) a b = Xyzzy (b -> (a, a))
class Foo f where
foo :: f Int -> a -> f a
foo' :: f (f a) -> Int -> f (f Int)
foo = undefined
foo' = undefined
instance Foo Maybe
instance Foo []
instance (Eq a, Foo f) => Foo ((,) (f a))
instance Foo (Either a)
instance Foo ((,,) a a)
instance Foo ((->) a)
instance Foo ((<~~) a)
class Foo f => Bar f a where
bar :: f a -> f Bool -> a
bar' :: f (f a) -> f (f (f b))
bar0, bar1 :: (f a, f a) -> (f b, f c)
bar = undefined
bar' = undefined
bar0 = undefined
bar1 = undefined
instance Bar Maybe Bool
instance Bar Maybe [a]
instance Bar [] (a, a)
instance Foo f => Bar (Either a) (f a)
instance Foo ((,,) a b) => Bar ((,,) a b) (a, b, a)
class Baz a where
baz :: a -> (forall a. a -> a) -> (b, forall c. c -> a) -> (b, c)
baz' :: b -> (forall b. b -> a) -> (forall b. b -> a) -> [(b, a)]
baz'' :: b -> (forall b. (forall b. b -> a) -> c) -> (forall c. c -> b)
baz = undefined
baz' = undefined
baz'' = undefined
instance Baz (a -> b)
instance Baz [c]
instance Baz (a, b, c)
instance Baz (a, [b], b, a)
data Quux a b c = Qx a | Qux a b | Quux a b c
instance Foo (Quux a b)
instance Bar (Quux a c) (Quux a b c)
instance Baz (Quux a b c)
class Norf a b where
type Plugh a c b
data Thud a c
norf :: Plugh a c b -> a -> (a -> c) -> b
norf = undefined
instance Norf Int Bool where
type Plugh Int [a] Bool = a
type Plugh Int (a, b) Bool = (a, [b])
data Thud Int (Quux a [a] c) = Thuud a | Thuuud Int Int
data Thud Int [a] = Thuuuud Bool
instance Norf [a] [b] where
type Plugh [a] (Maybe a) [b] = a
type Plugh [a] [b] [b] = Quux a b (a, b)
data Thud [a] (a, a, a) = Thd a
|
