blob: c148446881467c726c2338ad797cabe49c7a6e30 (
plain)
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
type GHC.TypeLits.AppendSymbol :: GHC.Types.Symbol
-> GHC.Types.Symbol -> GHC.Types.Symbol
type family GHC.TypeLits.AppendSymbol a b
type GHC.TypeLits.CharToNat :: Char -> GHC.Num.Natural.Natural
type family GHC.TypeLits.CharToNat a
type GHC.TypeLits.ConsSymbol :: Char
-> GHC.Types.Symbol -> GHC.Types.Symbol
type family GHC.TypeLits.ConsSymbol a b
type GHC.TypeLits.KnownChar :: Char -> Constraint
class GHC.TypeLits.KnownChar n where
GHC.TypeLits.charSing :: GHC.TypeLits.SChar n
{-# MINIMAL charSing #-}
type GHC.TypeLits.KnownSymbol :: GHC.Types.Symbol -> Constraint
class GHC.TypeLits.KnownSymbol n where
GHC.TypeLits.symbolSing :: GHC.TypeLits.SSymbol n
{-# MINIMAL symbolSing #-}
type GHC.TypeLits.NatToChar :: GHC.Num.Natural.Natural -> Char
type family GHC.TypeLits.NatToChar a
type GHC.TypeLits.SomeChar :: *
data GHC.TypeLits.SomeChar
= forall (n :: Char).
GHC.TypeLits.KnownChar n =>
GHC.TypeLits.SomeChar (Data.Proxy.Proxy n)
type GHC.TypeLits.SomeSymbol :: *
data GHC.TypeLits.SomeSymbol
= forall (n :: GHC.Types.Symbol).
GHC.TypeLits.KnownSymbol n =>
GHC.TypeLits.SomeSymbol (Data.Proxy.Proxy n)
type GHC.TypeLits.UnconsSymbol :: GHC.Types.Symbol
-> Maybe (Char, GHC.Types.Symbol)
type family GHC.TypeLits.UnconsSymbol a
GHC.TypeLits.charVal :: GHC.TypeLits.KnownChar n => proxy n -> Char
GHC.TypeLits.charVal' ::
GHC.TypeLits.KnownChar n => GHC.Prim.Proxy# n -> Char
GHC.TypeLits.cmpChar ::
(GHC.TypeLits.KnownChar a, GHC.TypeLits.KnownChar b) =>
proxy1 a -> proxy2 b -> Data.Type.Ord.OrderingI a b
GHC.TypeLits.cmpSymbol ::
(GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) =>
proxy1 a -> proxy2 b -> Data.Type.Ord.OrderingI a b
GHC.TypeLits.natVal ::
GHC.TypeNats.KnownNat n => proxy n -> Integer
GHC.TypeLits.natVal' ::
GHC.TypeNats.KnownNat n => GHC.Prim.Proxy# n -> Integer
GHC.TypeLits.sameChar ::
(GHC.TypeLits.KnownChar a, GHC.TypeLits.KnownChar b) =>
proxy1 a -> proxy2 b -> Maybe (a Data.Type.Equality.:~: b)
GHC.TypeLits.sameSymbol ::
(GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) =>
proxy1 a -> proxy2 b -> Maybe (a Data.Type.Equality.:~: b)
GHC.TypeLits.someCharVal :: Char -> GHC.TypeLits.SomeChar
GHC.TypeLits.someNatVal :: Integer -> Maybe GHC.TypeNats.SomeNat
GHC.TypeLits.someSymbolVal :: String -> GHC.TypeLits.SomeSymbol
GHC.TypeLits.symbolVal ::
GHC.TypeLits.KnownSymbol n => proxy n -> String
GHC.TypeLits.symbolVal' ::
GHC.TypeLits.KnownSymbol n => GHC.Prim.Proxy# n -> String
type (GHC.TypeNats.*) :: GHC.Num.Natural.Natural
-> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family (GHC.TypeNats.*) a b
type (GHC.TypeNats.+) :: GHC.Num.Natural.Natural
-> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family (GHC.TypeNats.+) a b
type (GHC.TypeNats.-) :: GHC.Num.Natural.Natural
-> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family (GHC.TypeNats.-) a b
type (Data.Type.Ord.<=) :: forall {t}. t -> t -> Constraint
type (Data.Type.Ord.<=) x y =
GHC.TypeError.Assert
(x Data.Type.Ord.<=? y) (Data.Type.Ord.LeErrMsg x y)
~ (() :: Constraint)
:: Constraint
type (Data.Type.Ord.<=?) :: forall k. k -> k -> Bool
type (Data.Type.Ord.<=?) m n =
Data.Type.Ord.OrdCond
(Data.Type.Ord.Compare m n) 'True 'True 'False
:: Bool
type GHC.TypeLits.Internal.CmpChar :: Char -> Char -> Ordering
type family GHC.TypeLits.Internal.CmpChar a b
type GHC.TypeNats.Internal.CmpNat :: GHC.Num.Natural.Natural
-> GHC.Num.Natural.Natural -> Ordering
type family GHC.TypeNats.Internal.CmpNat a b
type GHC.TypeLits.Internal.CmpSymbol :: GHC.Types.Symbol
-> GHC.Types.Symbol -> Ordering
type family GHC.TypeLits.Internal.CmpSymbol a b
type GHC.TypeNats.Div :: GHC.Num.Natural.Natural
-> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family GHC.TypeNats.Div a b
type GHC.TypeError.ErrorMessage :: *
data GHC.TypeError.ErrorMessage
= GHC.TypeError.Text GHC.Types.Symbol
| forall t. GHC.TypeError.ShowType t
| GHC.TypeError.ErrorMessage
GHC.TypeError.:<>:
GHC.TypeError.ErrorMessage
| GHC.TypeError.ErrorMessage
GHC.TypeError.:$$:
GHC.TypeError.ErrorMessage
type GHC.TypeNats.KnownNat :: GHC.TypeNats.Nat -> Constraint
class GHC.TypeNats.KnownNat n where
GHC.TypeNats.natSing :: GHC.TypeNats.SNat n
{-# MINIMAL natSing #-}
type GHC.TypeNats.Log2 :: GHC.Num.Natural.Natural
-> GHC.Num.Natural.Natural
type family GHC.TypeNats.Log2 a
type GHC.TypeNats.Mod :: GHC.Num.Natural.Natural
-> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family GHC.TypeNats.Mod a b
type GHC.TypeNats.Nat :: *
type GHC.TypeNats.Nat = GHC.Num.Natural.Natural
type GHC.Num.Natural.Natural :: *
data GHC.Num.Natural.Natural
= GHC.Num.Natural.NS GHC.Prim.Word#
| GHC.Num.Natural.NB GHC.Prim.ByteArray#
type role Data.Type.Ord.OrderingI nominal nominal
type Data.Type.Ord.OrderingI :: forall {k}. k -> k -> *
data Data.Type.Ord.OrderingI a b where
Data.Type.Ord.LTI :: forall {k} (a :: k) (b :: k).
(Data.Type.Ord.Compare a b ~ 'LT) =>
Data.Type.Ord.OrderingI a b
Data.Type.Ord.EQI :: forall {k} (a :: k).
(Data.Type.Ord.Compare a a ~ 'EQ) =>
Data.Type.Ord.OrderingI a a
Data.Type.Ord.GTI :: forall {k} (a :: k) (b :: k).
(Data.Type.Ord.Compare a b ~ 'GT) =>
Data.Type.Ord.OrderingI a b
type GHC.TypeNats.SomeNat :: *
data GHC.TypeNats.SomeNat
= forall (n :: GHC.TypeNats.Nat).
GHC.TypeNats.KnownNat n =>
GHC.TypeNats.SomeNat (Data.Proxy.Proxy n)
type GHC.Types.Symbol :: *
data GHC.Types.Symbol
type GHC.TypeError.TypeError :: forall b.
GHC.TypeError.ErrorMessage -> b
type family GHC.TypeError.TypeError a where
type (GHC.TypeNats.^) :: GHC.Num.Natural.Natural
-> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family (GHC.TypeNats.^) a b
GHC.TypeNats.cmpNat ::
(GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b) =>
proxy1 a -> proxy2 b -> Data.Type.Ord.OrderingI a b
GHC.TypeNats.sameNat ::
(GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b) =>
proxy1 a -> proxy2 b -> Maybe (a Data.Type.Equality.:~: b)
|
