Module

Data.Typelevel.Num

Re-exports from Data.Typelevel.Num.Aliases

#D99 

type D99 = D9 :* D9

#D98 

type D98 = D9 :* D8

#D97 

type D97 = D9 :* D7

#D96 

type D96 = D9 :* D6

#D95 

type D95 = D9 :* D5

#D94 

type D94 = D9 :* D4

#D93 

type D93 = D9 :* D3

#D92 

type D92 = D9 :* D2

#D91 

type D91 = D9 :* D1

#D90 

type D90 = D9 :* D0

#D89 

type D89 = D8 :* D9

#D88 

type D88 = D8 :* D8

#D87 

type D87 = D8 :* D7

#D86 

type D86 = D8 :* D6

#D85 

type D85 = D8 :* D5

#D84 

type D84 = D8 :* D4

#D83 

type D83 = D8 :* D3

#D82 

type D82 = D8 :* D2

#D81 

type D81 = D8 :* D1

#D80 

type D80 = D8 :* D0

#D79 

type D79 = D7 :* D9

#D78 

type D78 = D7 :* D8

#D77 

type D77 = D7 :* D7

#D76 

type D76 = D7 :* D6

#D75 

type D75 = D7 :* D5

#D74 

type D74 = D7 :* D4

#D73 

type D73 = D7 :* D3

#D72 

type D72 = D7 :* D2

#D71 

type D71 = D7 :* D1

#D70 

type D70 = D7 :* D0

#D69 

type D69 = D6 :* D9

#D68 

type D68 = D6 :* D8

#D67 

type D67 = D6 :* D7

#D66 

type D66 = D6 :* D6

#D65 

type D65 = D6 :* D5

#D64 

type D64 = D6 :* D4

#D63 

type D63 = D6 :* D3

#D62 

type D62 = D6 :* D2

#D61 

type D61 = D6 :* D1

#D60 

type D60 = D6 :* D0

#D59 

type D59 = D5 :* D9

#D58 

type D58 = D5 :* D8

#D57 

type D57 = D5 :* D7

#D56 

type D56 = D5 :* D6

#D55 

type D55 = D5 :* D5

#D54 

type D54 = D5 :* D4

#D53 

type D53 = D5 :* D3

#D52 

type D52 = D5 :* D2

#D51 

type D51 = D5 :* D1

#D50 

type D50 = D5 :* D0

#D49 

type D49 = D4 :* D9

#D48 

type D48 = D4 :* D8

#D47 

type D47 = D4 :* D7

#D46 

type D46 = D4 :* D6

#D45 

type D45 = D4 :* D5

#D44 

type D44 = D4 :* D4

#D43 

type D43 = D4 :* D3

#D42 

type D42 = D4 :* D2

#D41 

type D41 = D4 :* D1

#D40 

type D40 = D4 :* D0

#D39 

type D39 = D3 :* D9

#D38 

type D38 = D3 :* D8

#D37 

type D37 = D3 :* D7

#D36 

type D36 = D3 :* D6

#D35 

type D35 = D3 :* D5

#D34 

type D34 = D3 :* D4

#D33 

type D33 = D3 :* D3

#D32 

type D32 = D3 :* D2

#D31 

type D31 = D3 :* D1

#D30 

type D30 = D3 :* D0

#D29 

type D29 = D2 :* D9

#D28 

type D28 = D2 :* D8

#D27 

type D27 = D2 :* D7

#D26 

type D26 = D2 :* D6

#D25 

type D25 = D2 :* D5

#D24 

type D24 = D2 :* D4

#D23 

type D23 = D2 :* D3

#D22 

type D22 = D2 :* D2

#D21 

type D21 = D2 :* D1

#D20 

type D20 = D2 :* D0

#D19 

type D19 = D1 :* D9

#D18 

type D18 = D1 :* D8

#D17 

type D17 = D1 :* D7

#D16 

type D16 = D1 :* D6

#D15 

type D15 = D1 :* D5

#D14 

type D14 = D1 :* D4

#D13 

type D13 = D1 :* D3

#D12 

type D12 = D1 :* D2

#D11 

type D11 = D1 :* D1

#D100 

type D100 = (D1 :* D0) :* D0

#D10 

type D10 = D1 :* D0

#d99 

d99 :: D99

#d98 

d98 :: D98

#d97 

d97 :: D97

#d96 

d96 :: D96

#d95 

d95 :: D95

#d94 

d94 :: D94

#d93 

d93 :: D93

#d92 

d92 :: D92

#d91 

d91 :: D91

#d90 

d90 :: D90

#d89 

d89 :: D89

#d88 

d88 :: D88

#d87 

d87 :: D87

#d86 

d86 :: D86

#d85 

d85 :: D85

#d84 

d84 :: D84

#d83 

d83 :: D83

#d82 

d82 :: D82

#d81 

d81 :: D81

#d80 

d80 :: D80

#d79 

d79 :: D79

#d78 

d78 :: D78

#d77 

d77 :: D77

#d76 

d76 :: D76

#d75 

d75 :: D75

#d74 

d74 :: D74

#d73 

d73 :: D73

#d72 

d72 :: D72

#d71 

d71 :: D71

#d70 

d70 :: D70

#d69 

d69 :: D69

#d68 

d68 :: D68

#d67 

d67 :: D67

#d66 

d66 :: D66

#d65 

d65 :: D65

#d64 

d64 :: D64

#d63 

d63 :: D63

#d62 

d62 :: D62

#d61 

d61 :: D61

#d60 

d60 :: D60

#d59 

d59 :: D59

#d58 

d58 :: D58

#d57 

d57 :: D57

#d56 

d56 :: D56

#d55 

d55 :: D55

#d54 

d54 :: D54

#d53 

d53 :: D53

#d52 

d52 :: D52

#d51 

d51 :: D51

#d50 

d50 :: D50

#d49 

d49 :: D49

#d48 

d48 :: D48

#d47 

d47 :: D47

#d46 

d46 :: D46

#d45 

d45 :: D45

#d44 

d44 :: D44

#d43 

d43 :: D43

#d42 

d42 :: D42

#d41 

d41 :: D41

#d40 

d40 :: D40

#d39 

d39 :: D39

#d38 

d38 :: D38

#d37 

d37 :: D37

#d36 

d36 :: D36

#d35 

d35 :: D35

#d34 

d34 :: D34

#d33 

d33 :: D33

#d32 

d32 :: D32

#d31 

d31 :: D31

#d30 

d30 :: D30

#d29 

d29 :: D29

#d28 

d28 :: D28

#d27 

d27 :: D27

#d26 

d26 :: D26

#d25 

d25 :: D25

#d24 

d24 :: D24

#d23 

d23 :: D23

#d22 

d22 :: D22

#d21 

d21 :: D21

#d20 

d20 :: D20

#d19 

d19 :: D19

#d18 

d18 :: D18

#d17 

d17 :: D17

#d16 

d16 :: D16

#d15 

d15 :: D15

#d14 

d14 :: D14

#d13 

d13 :: D13

#d12 

d12 :: D12

#d11 

d11 :: D11

#d10 

d10 :: D10

Re-exports from Data.Typelevel.Num.Ops

#PredecessorOfZeroError 

data PredecessorOfZeroError t

#Add 

class (AddP x y z, AddP y x z) <= Add x y z | x y -> z, z x -> y, z y -> x

Instances

#AddP 

class (Nat x) <= AddP x y z | x y -> z, z x -> y

Instances

#CS 

class CS r1 r2 r3 | r1 r2 -> r3

Instances

#Div 

class Div x y z | x y -> z, x z -> y, y z -> x

Instances

#Div10 

class (Nat x) <= Div10 x q | x -> q, q -> x

Instances

#DivMod 

class (Nat x, Pos y) <= DivMod x y q r | x y -> q r

Instances

#DivMod10 

class (Nat i, Nat x) <= DivMod10 x i l | i l -> x, x -> i l

Instances

#DivModP 

class (Nat x, Pos y) <= DivModP x y q r cmp | x y cmp -> q r, q r cmp y -> x, q r cmp x -> y

Instances

#Eq 

class Eq x y

Instances

#Failure 

class Failure t

#GCD 

class (Nat x, Nat y, Nat gcd) <= GCD x y gcd | x y -> gcd

Instances

#GCDP 

class (Nat x, Nat y, Nat gcd) <= GCDP x y yz cmp gcd | x y yz cmp -> gcd

Instances

#Gt 

class Gt x y

Instances

#GtEq 

class GtEq x y

Instances

#IsDivBy 

class (Pos d) <= IsDivBy d x

Instances

#Lt 

class Lt x y

Instances

#LtEq 

class LtEq x y

Instances

#Max 

class Max x y z | x y -> z

Instances

#MaxP 

class MaxP x y b r | x y b -> r

Instances

#Min 

class Min x y z | x y -> z

Instances

#Mod 

class Mod x y r | x y -> r

Instances

#Mul 

class (Nat x, Nat y) <= Mul x y z | x y -> z

Instances

#Mul10 

class (Nat q) <= Mul10 x q | x -> q, q -> x

Instances

#Pred 

class (Pos x) <= Pred x y | x -> y, y -> x

Instances

#Sub 

class Sub x y z | x y -> z, z x -> y, z y -> x

Instances

#Succ 

class (Nat x, Pos y) <= Succ x y | x -> y, y -> x

Instances

#SuccP 

class SuccP xh xl yh yl yz | xh xl -> yh yl yz, yh yl yz -> xh xl

Instances

#Trich 

class (Nat x, Nat y) <= Trich x y r | x y -> r

Instances

#trich 

trich :: forall x y r. Trich x y r => x -> y -> r

#succ 

succ :: forall x y. Succ x y => x -> y

#sub 

sub :: forall x y z. Sub x y z => x -> y -> z

#pred 

pred :: forall x y. Pred x y => x -> y

#mul10 

mul10 :: forall x q. Mul10 x q => x -> q

#mul 

mul :: forall x y z. Mul x y z => x -> y -> z

#mod 

mod :: forall x y r. Mod x y r => x -> y -> r

#min 

min :: forall x y z. Min x y z => x -> y -> z

#max 

max :: forall x y z. Max x y z => x -> y -> z

#lteq 

lteq :: forall x y. LtEq x y => x -> y -> Unit

#lt 

lt :: forall x y. Lt x y => x -> y -> Unit

#isDivBy 

isDivBy :: forall d x. IsDivBy d x => d -> x

#gteq 

gteq :: forall x y. GtEq x y => x -> y -> Unit

#gt 

gt :: forall x y. Gt x y => x -> y -> Unit

#gcd 

gcd :: forall x y z. GCD x y z => x -> y -> z

#eq 

eq :: forall x y. Eq x y => x -> y -> Unit

#divMod10 

divMod10 :: forall x r q. DivMod10 x q r => x -> Tuple q r

#divMod 

divMod :: forall x y q r. DivMod x y q r => x -> y -> Tuple q r

#div10 

div10 :: forall x q. Div10 x q => x -> q

#div 

div :: forall x y z. Div x y z => x -> y -> z

#add 

add :: forall x y z. Add x y z => x -> y -> z

#(>=)

Operator alias for Data.Typelevel.Num.Ops.gteq (left-associative / precedence 4)

#(>)

Operator alias for Data.Typelevel.Num.Ops.gt (left-associative / precedence 4)

#(==)

Operator alias for Data.Typelevel.Num.Ops.eq (left-associative / precedence 4)

#(<=)

Operator alias for Data.Typelevel.Num.Ops.lteq (left-associative / precedence 4)

#(<)

Operator alias for Data.Typelevel.Num.Ops.lt (left-associative / precedence 4)

#(-)

Operator alias for Data.Typelevel.Num.Ops.sub (left-associative / precedence 6)

#(+)

Operator alias for Data.Typelevel.Num.Ops.add (left-associative / precedence 6)

#(*)

Operator alias for Data.Typelevel.Num.Ops.mul (left-associative / precedence 7)

Re-exports from Data.Typelevel.Num.Reps

#NumCons 

data NumCons a b

Constructors

Instances

#D9 

data D9

Instances

#D8 

data D8

Instances

#D7 

data D7

Instances

#D6 

data D6

Instances

#D5 

data D5

Instances

#D4 

data D4

Instances

#D3 

data D3

Instances

#D2 

data D2

Instances

#D1 

data D1

Instances

#D0 

data D0

Instances

#d9 

d9 :: D9

#d8 

d8 :: D8

#d7 

d7 :: D7

#d6 

d6 :: D6

#d5 

d5 :: D5

#d4 

d4 :: D4

#d3 

d3 :: D3

#d2 

d2 :: D2

#d1 

d1 :: D1

#d0 

d0 :: D0

#type (:*)

Operator alias for Data.Typelevel.Num.Reps.NumCons (non-associative / precedence 6)

Re-exports from Data.Typelevel.Num.Sets

#Nat 

class Nat n  where

Members

Instances

#Pos 

class (Nat n) <= Pos n

Instances

#toInt' 

toInt' :: forall n. Nat n => Proxy n -> Int

Sugar for toInt, providing a more intuitive type

#subLastDec 

subLastDec :: forall x d. Nat (x :* d) => Nat x => x :* d -> Int

#reifyIntP 

reifyIntP :: forall r. Int -> (forall n. Pos n => n -> r) -> r

#reifyInt 

reifyInt :: forall r. Int -> (forall n. Nat n => n -> r) -> r

#div10Dec 

div10Dec :: forall x d. Nat (x :* d) => x :* d -> x

Modules