The Backpack patch.
[ghc.git] / testsuite / tests / backpack / should_compile / bkp15.bkp
1 {-# LANGUAGE RankNTypes, DatatypeContexts, CApiFFI, GADTs, TypeFamilies, DefaultSignatures, MultiParamTypeClasses, FunctionalDependencies, PatternSynonyms #-}
2
3 -- Reflexivity test, bang on the units with as much
4 -- stuff as we can.
5 unit p where
6     signature H where
7         x :: (forall a. a -> a) -> (Int, Bool)
8         data Eq a => T a = T (a -> a) | S (S a)
9         data S a = R (T a)
10         data {-# CTYPE "Foo" #-} Foo where
11             Foo :: Foo
12         newtype F a = F a
13         type X m a = m a
14         type family Elem c
15         class Eq a => Bloop a b | a -> b where
16             data GMap a (v :: * -> *) :: *
17             xa :: a -> a -> Bool
18             xa = (==)
19             y :: a -> a -> Ordering
20             default y :: Ord a => a -> a -> Ordering
21             y = compare
22             {-# MINIMAL xa | y #-}
23         -- type instance Elem Int = Bool
24         -- pattern Blub n = ("foo", n)
25
26 -- keept his synced up!
27 unit q where
28     signature H where
29         x :: (forall a. a -> a) -> (Int, Bool)
30         data Eq a => T a = T (a -> a) | S (S a)
31         data S a = R (T a)
32         data {-# CTYPE "Foo" #-} Foo where
33             Foo :: Foo
34         newtype F a = F a
35         type X m a = m a
36         type family Elem c
37         class Eq a => Bloop a b | a -> b where
38             data GMap a (v :: * -> *) :: *
39             xa :: a -> a -> Bool
40             xa = (==)
41             y :: a -> a -> Ordering
42             default y :: Ord a => a -> a -> Ordering
43             y = compare
44             {-# MINIMAL xa | y #-}
45         -- type instance Elem Int = Bool
46         -- pattern Blub n = ("foo", n)
47
48 unit r where
49     dependency p[H=<H>]
50     dependency q[H=<H>]
51     module M where
52         import H
53         a = x id
54         b = T (id :: String -> String)
55         c = S (R b)
56         d = F Foo :: X F Foo
57         type instance Elem Bool = Int
58         instance Bloop Bool Bool where
59             data GMap Bool v = GMapBool (v Bool)
60             xa a b = a == not b
61
62 unit h-impl where
63     module H where
64         x :: (forall a. a -> a) -> (Int, Bool)
65         x f = (f 2, f True)
66         data Eq a => T a = T (a -> a) | S (S a)
67         data S a = R (T a)
68         data {-# CTYPE "Foo" #-} Foo where
69             Foo :: Foo
70         newtype F a = F a
71         type X m a = m a
72         type family Elem c
73         class Eq a => Bloop a b | a -> b where
74             data GMap a (v :: * -> *) :: *
75             xa :: a -> a -> Bool
76             xa = (==)
77             y :: a -> a -> Ordering
78             default y :: Ord a => a -> a -> Ordering
79             y = compare
80             {-# MINIMAL xa | y #-}
81 unit s where
82     dependency r[H=h-impl:H]