94678af234d59c5acc8fb0f42aed32947b4f8fa4
[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             -- TODO: Putting default definitions in the signature file
19             -- causes references to DFuns, which we choke on. These should
20             -- be disallowed.
21             -- xa = (==)
22             y :: a -> a -> Ordering
23             -- default y :: Ord a => a -> a -> Ordering
24             -- y = compare
25             {-# MINIMAL xa | y #-}
26         -- type instance Elem Int = Bool
27         -- pattern Blub n = ("foo", n)
28
29 -- keept his synced up!
30 unit q where
31     signature H where
32         x :: (forall a. a -> a) -> (Int, Bool)
33         data Eq a => T a = T (a -> a) | S (S a)
34         data S a = R (T a)
35         data {-# CTYPE "Foo" #-} Foo where
36             Foo :: Foo
37         newtype F a = F a
38         type X m a = m a
39         type family Elem c
40         class Eq a => Bloop a b | a -> b where
41             data GMap a (v :: * -> *) :: *
42             xa :: a -> a -> Bool
43             -- xa = (==)
44             y :: a -> a -> Ordering
45             -- default y :: Ord a => a -> a -> Ordering
46             -- y = compare
47             {-# MINIMAL xa | y #-}
48         -- type instance Elem Int = Bool
49         -- pattern Blub n = ("foo", n)
50
51 unit r where
52     dependency p[H=<H>]
53     dependency q[H=<H>]
54     module M where
55         import H
56         a = x id
57         b = T (id :: String -> String)
58         c = S (R b)
59         d = F Foo :: X F Foo
60         type instance Elem Bool = Int
61         instance Bloop Bool Bool where
62             data GMap Bool v = GMapBool (v Bool)
63             xa a b = a == not b
64
65 unit h-impl where
66     module H where
67         x :: (forall a. a -> a) -> (Int, Bool)
68         x f = (f 2, f True)
69         data Eq a => T a = T (a -> a) | S (S a)
70         data S a = R (T a)
71         data {-# CTYPE "Foo" #-} Foo where
72             Foo :: Foo
73         newtype F a = F a
74         type X m a = m a
75         type family Elem c
76         class Eq a => Bloop a b | a -> b where
77             data GMap a (v :: * -> *) :: *
78             xa :: a -> a -> Bool
79             -- xa = (==)
80             y :: a -> a -> Ordering
81             -- default y :: Ord a => a -> a -> Ordering
82             -- y = compare
83             {-# MINIMAL xa | y #-}
84 unit s where
85     dependency r[H=h-impl:H]