Module

Data.Typelevel.Num

Package
purescript-typelevel
Repository
bodil/purescript-typelevel

Re-exports from Data.Typelevel.Num.Aliases

#D99 Source

type D99 = D9 :* D9

#D98 Source

type D98 = D9 :* D8

#D97 Source

type D97 = D9 :* D7

#D96 Source

type D96 = D9 :* D6

#D95 Source

type D95 = D9 :* D5

#D94 Source

type D94 = D9 :* D4

#D93 Source

type D93 = D9 :* D3

#D92 Source

type D92 = D9 :* D2

#D91 Source

type D91 = D9 :* D1

#D90 Source

type D90 = D9 :* D0

#D89 Source

type D89 = D8 :* D9

#D88 Source

type D88 = D8 :* D8

#D87 Source

type D87 = D8 :* D7

#D86 Source

type D86 = D8 :* D6

#D85 Source

type D85 = D8 :* D5

#D84 Source

type D84 = D8 :* D4

#D83 Source

type D83 = D8 :* D3

#D82 Source

type D82 = D8 :* D2

#D81 Source

type D81 = D8 :* D1

#D80 Source

type D80 = D8 :* D0

#D79 Source

type D79 = D7 :* D9

#D78 Source

type D78 = D7 :* D8

#D77 Source

type D77 = D7 :* D7

#D76 Source

type D76 = D7 :* D6

#D75 Source

type D75 = D7 :* D5

#D74 Source

type D74 = D7 :* D4

#D73 Source

type D73 = D7 :* D3

#D72 Source

type D72 = D7 :* D2

#D71 Source

type D71 = D7 :* D1

#D70 Source

type D70 = D7 :* D0

#D69 Source

type D69 = D6 :* D9

#D68 Source

type D68 = D6 :* D8

#D67 Source

type D67 = D6 :* D7

#D66 Source

type D66 = D6 :* D6

#D65 Source

type D65 = D6 :* D5

#D64 Source

type D64 = D6 :* D4

#D63 Source

type D63 = D6 :* D3

#D62 Source

type D62 = D6 :* D2

#D61 Source

type D61 = D6 :* D1

#D60 Source

type D60 = D6 :* D0

#D59 Source

type D59 = D5 :* D9

#D58 Source

type D58 = D5 :* D8

#D57 Source

type D57 = D5 :* D7

#D56 Source

type D56 = D5 :* D6

#D55 Source

type D55 = D5 :* D5

#D54 Source

type D54 = D5 :* D4

#D53 Source

type D53 = D5 :* D3

#D52 Source

type D52 = D5 :* D2

#D51 Source

type D51 = D5 :* D1

#D50 Source

type D50 = D5 :* D0

#D49 Source

type D49 = D4 :* D9

#D48 Source

type D48 = D4 :* D8

#D47 Source

type D47 = D4 :* D7

#D46 Source

type D46 = D4 :* D6

#D45 Source

type D45 = D4 :* D5

#D44 Source

type D44 = D4 :* D4

#D43 Source

type D43 = D4 :* D3

#D42 Source

type D42 = D4 :* D2

#D41 Source

type D41 = D4 :* D1

#D40 Source

type D40 = D4 :* D0

#D39 Source

type D39 = D3 :* D9

#D38 Source

type D38 = D3 :* D8

#D37 Source

type D37 = D3 :* D7

#D36 Source

type D36 = D3 :* D6

#D35 Source

type D35 = D3 :* D5

#D34 Source

type D34 = D3 :* D4

#D33 Source

type D33 = D3 :* D3

#D32 Source

type D32 = D3 :* D2

#D31 Source

type D31 = D3 :* D1

#D30 Source

type D30 = D3 :* D0

#D29 Source

type D29 = D2 :* D9

#D28 Source

type D28 = D2 :* D8

#D27 Source

type D27 = D2 :* D7

#D26 Source

type D26 = D2 :* D6

#D25 Source

type D25 = D2 :* D5

#D24 Source

type D24 = D2 :* D4

#D23 Source

type D23 = D2 :* D3

#D22 Source

type D22 = D2 :* D2

#D21 Source

type D21 = D2 :* D1

#D20 Source

type D20 = D2 :* D0

#D19 Source

type D19 = D1 :* D9

#D18 Source

type D18 = D1 :* D8

#D17 Source

type D17 = D1 :* D7

#D16 Source

type D16 = D1 :* D6

#D15 Source

type D15 = D1 :* D5

#D14 Source

type D14 = D1 :* D4

#D13 Source

type D13 = D1 :* D3

#D12 Source

type D12 = D1 :* D2

#D11 Source

type D11 = D1 :* D1

#D100 Source

type D100 = D1 :* D0 :* D0

#D10 Source

type D10 = D1 :* D0

Re-exports from Data.Typelevel.Num.Ops

#PredecessorOfZeroError Source

#GT Source

data GT

Instances

#Add Source

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

Instances

#AddP Source

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

Instances

#CS Source

class CS r1 r2 r3 | r1 r2 -> r3

Instances

#Div Source

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

Instances

#Div10 Source

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

Instances

#DivMod Source

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

Instances

#DivMod10 Source

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

Instances

#DivModP Source

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 Source

class Eq x y 

Instances

#Failure Source

class Failure t 

#GCD Source

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

Instances

#GCDP Source

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

Instances

#Gt Source

class Gt x y 

Instances

#GtEq Source

class GtEq x y 

Instances

#IsDivBy Source

class (Pos d) <= IsDivBy d x 

Instances

#Lt Source

class Lt x y 

Instances

#LtEq Source

class LtEq x y 

Instances

#Max Source

class Max x y z | x y -> z

Instances

#MaxP Source

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

Instances

#Min Source

class Min x y z | x y -> z

Instances

#Mod Source

class Mod x y r | x y -> r

Instances

#Mul Source

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

Instances

#Mul10 Source

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

Instances

#Pred Source

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

Instances

#Sub Source

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

Instances

#Succ Source

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

Instances

#SuccP Source

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

Instances

#Trich Source

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

Instances

#trich Source

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

#succ Source

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

#sub Source

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

#pred Source

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

#mul10 Source

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

#mul Source

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

#mod Source

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

#min Source

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

#max Source

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

#lteq Source

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

#lt Source

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

#isDivBy Source

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

#gteq Source

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

#gt Source

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

#gcd Source

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

#eq Source

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

#divMod10 Source

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

#divMod Source

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

#div10 Source

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

#div Source

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

#add Source

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

#(>=) Source

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

#(>) Source

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

#(==) Source

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

#(<=) Source

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

#(<) Source

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

#(-) Source

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

#(+) Source

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

#(*) Source

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

Re-exports from Data.Typelevel.Num.Reps

#NumCons Source

data NumCons a b

Constructors

#D9 Source

data D9

Instances

#D8 Source

data D8

Instances

#D7 Source

data D7

Instances

#D6 Source

data D6

Instances

#D5 Source

data D5

Instances

#D4 Source

data D4

Instances

#D3 Source

data D3

Instances

#D2 Source

data D2

Instances

#D1 Source

data D1

Instances

#D0 Source

data D0

Instances

#type (:*) Source

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

Re-exports from Data.Typelevel.Num.Sets

#Nat Source

class Nat n  where

Members

Instances

#Pos Source

class (Nat n) <= Pos n 

Instances

#subLastDec Source

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

#reifyIntP Source

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

#reifyInt Source

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

#div10Dec Source

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