natural-arithmetic-0.2.1.0: Arithmetic of natural numbers
Safe HaskellNone
LanguageHaskell2010

Arithmetic.Nat

Synopsis

Addition

plus :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Nat (a + b) #

Add two numbers.

plus# :: forall (a :: Nat) (b :: Nat). Nat# a -> Nat# b -> Nat# (a + b) #

Variant of plus for unboxed nats.

Subtraction

monus :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Maybe (Difference a b) #

Subtract the second argument from the first argument.

Division

divide :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Nat (Div a b) #

Divide two numbers. Rounds down (towards zero)

divideRoundingUp :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Nat (Div (a - 1) b + 1) #

Divide two numbers. Rounds up (away from zero)

Multiplication

times :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Nat (a * b) #

Multiply two numbers.

Successor

succ :: forall (a :: Nat). Nat a -> Nat (a + 1) #

The successor of a number.

succ# :: forall (a :: Nat). Nat# a -> Nat# (a + 1) #

Unlifted variant of succ.

Compare

testEqual :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Maybe (a :=: b) #

Are the two arguments equal to one another?

testEqual# :: forall (a :: Nat) (b :: Nat). Nat# a -> Nat# b -> MaybeVoid# (a :=:# b) #

testLessThan :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Maybe (a < b) #

Is the first argument strictly less than the second argument?

testLessThan# :: forall (a :: Nat) (b :: Nat). Nat# a -> Nat# b -> MaybeVoid# (a <# b) #

testLessThanEqual :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Maybe (a <= b) #

Is the first argument less-than-or-equal-to the second argument?

testZero :: forall (a :: Nat). Nat a -> Either (0 :=: a) (0 < a) #

Is zero equal to this number or less than it?

testZero# :: forall (a :: Nat). Nat# a -> EitherVoid# (0 :=:# a) (0 <# a) #

(=?) :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Maybe (a :=: b) #

Infix synonym of testEqual.

(<?) :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Maybe (a < b) #

Infix synonym of testLessThan.

(<?#) :: forall (a :: Nat) (b :: Nat). Nat# a -> Nat# b -> MaybeVoid# (a <# b) #

(<=?) :: forall (a :: Nat) (b :: Nat). Nat a -> Nat b -> Maybe (a <= b) #

Infix synonym of testLessThanEqual.

Constants

zero :: Nat 0 #

The number zero.

one :: Nat 1 #

The number one.

two :: Nat 2 #

The number two.

three :: Nat 3 #

The number three.

constant :: forall (n :: Nat). KnownNat n => Nat n #

Use GHC's built-in type-level arithmetic to create a witness of a type-level number. This only reduces if the number is a constant.

constant# :: forall (n :: Nat). KnownNat n => (# #) -> Nat# n #

Unboxed Constants

zero# :: (# #) -> Nat# 0 #

The number zero. Unboxed.

one# :: (# #) -> Nat# 1 #

The number one. Unboxed.

Unboxed Pattern Synonyms

pattern N0# :: Nat# 0 #

pattern N1# :: Nat# 1 #

pattern N2# :: Nat# 2 #

pattern N3# :: Nat# 3 #

pattern N4# :: Nat# 4 #

pattern N5# :: Nat# 5 #

pattern N6# :: Nat# 6 #

pattern N7# :: Nat# 7 #

pattern N8# :: Nat# 8 #

pattern N16# :: Nat# 16 #

pattern N32# :: Nat# 32 #

pattern N64# :: Nat# 64 #

pattern N128# :: Nat# 128 #

pattern N256# :: Nat# 256 #

pattern N512# :: Nat# 512 #

pattern N1024# :: Nat# 1024 #

pattern N2048# :: Nat# 2048 #

pattern N4096# :: Nat# 4096 #

Convert

demote :: forall (n :: Nat). Nat n -> Int #

Extract the Int from a Nat. This is intended to be used at a boundary where a safe interface meets the unsafe primitives on top of which it is built.

demote# :: forall (n :: Nat). Nat# n -> Int# #

unlift :: forall (n :: Nat). Nat n -> Nat# n #

lift :: forall (n :: Nat). Nat# n -> Nat n #

with :: Int -> (forall (n :: Nat). Nat n -> a) -> a #

Run a computation on a witness of a type-level number. The argument Int must be greater than or equal to zero. This is not checked. Failure to upload this invariant will lead to a segfault.

with# :: Int# -> (forall (n :: Nat). Nat# n -> a) -> a #