Safe Haskell	Safe
Language	Haskell2010

Type.Data.Num

Synopsis

type family Negate x
negate :: Proxy x -> Proxy (Negate x)
type family IsPositive x
isPositive :: Proxy x -> Proxy (IsPositive x)
type family IsZero x
isZero :: Proxy x -> Proxy (IsZero x)
type family IsNegative x
isNegative :: Proxy x -> Proxy (IsNegative x)
type family IsNatural x
isNatural :: Proxy x -> Proxy (IsNatural x)
type family One repr
one :: Proxy repr -> Proxy (One repr)
type family Succ x
succ :: Proxy x -> Proxy (Succ x)
type family Pred x
pred :: Proxy x -> Proxy (Pred x)
type family IsEven x
isEven :: Proxy x -> Proxy (IsEven x)
type family IsOdd x
isOdd :: Proxy x -> Proxy (IsOdd x)
type family x :+: y
add :: Proxy x -> Proxy y -> Proxy (x :+: y)
type family x :-: y
sub :: Proxy x -> Proxy y -> Proxy (x :-: y)
type family x :*: y
mul :: Proxy x -> Proxy y -> Proxy (x :*: y)
type family Mul2 x
mul2 :: Proxy x -> Proxy (Mul2 x)
type family Pow2 x
pow2 :: Proxy x -> Proxy (Pow2 x)
type family Log2Ceil x
log2Ceil :: Proxy x -> Proxy (Log2Ceil x)
type family DivMod x y
divMod :: Proxy x -> Proxy y -> Proxy (DivMod x y)
type family Div x y
div :: Proxy x -> Proxy y -> Proxy (Div x y)
type family Mod x y
mod :: Proxy x -> Proxy y -> Proxy (Mod x y)
type family Div2 x
div2 :: Proxy x -> Proxy (Div2 x)
type family Fac x
fac :: Proxy x -> Proxy (Fac x)
newtype Singleton d = Singleton Integer
class Representation r where
- reifyIntegral :: Proxy r -> Integer -> (forall s. (Integer s, Repr s ~ r) => Proxy s -> a) -> a
class Representation (Repr x) => Integer x where
- type Repr x
- singleton :: Singleton x
class Integer x => Natural x
class Integer x => Positive x
class Integer x => Negative x
integerFromSingleton :: Integer x => Singleton x -> Integer
integralFromSingleton :: (Integer x, Num y) => Singleton x -> y
singletonFromProxy :: Integer x => Proxy x -> Singleton x
integralFromProxy :: (Integer x, Num y) => Proxy x -> y
fromInteger :: (Integer x, Num y) => Proxy x -> y
reifyPositive :: Representation r => Proxy r -> Integer -> (forall s. (Positive s, Repr s ~ r) => Proxy s -> a) -> Maybe a
reifyNegative :: Representation r => Proxy r -> Integer -> (forall s. (Negative s, Repr s ~ r) => Proxy s -> a) -> Maybe a
reifyNatural :: Representation r => Proxy r -> Integer -> (forall s. (Natural s, Repr s ~ r) => Proxy s -> a) -> Maybe a

Documentation

type family Negate x Source #

Negate x evaluates to the additive inverse of (i.e., minus) x.

Instances

type Negate (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type Negate (Dec x)

negate :: Proxy x -> Proxy (Negate x) Source #

type family IsPositive x Source #

Instances

type IsPositive (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type IsPositive (Dec x)

isPositive :: Proxy x -> Proxy (IsPositive x) Source #

type family IsZero x Source #

Instances

type IsZero (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type IsZero (Dec x)

isZero :: Proxy x -> Proxy (IsZero x) Source #

type family IsNegative x Source #

Instances

type IsNegative (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type IsNegative (Dec x)

isNegative :: Proxy x -> Proxy (IsNegative x) Source #

type family IsNatural x Source #

Instances

type IsNatural (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type IsNatural (Dec x)

isNatural :: Proxy x -> Proxy (IsNatural x) Source #

type family One repr Source #

Instances

type One Decimal Source #
Instance details Defined in Type.Data.Num.Decimal.Number type One Decimal

one :: Proxy repr -> Proxy (One repr) Source #

type family Succ x Source #

Instances

type Succ (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type Succ (Dec x) = Dec (Succ x)

succ :: Proxy x -> Proxy (Succ x) Source #

type family Pred x Source #

Instances

type Pred (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type Pred (Dec x) = Dec (Pred x)

pred :: Proxy x -> Proxy (Pred x) Source #

type family IsEven x Source #

Instances

type IsEven (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type IsEven (Dec x) = IsEven x

isEven :: Proxy x -> Proxy (IsEven x) Source #

type family IsOdd x Source #

Instances

type IsOdd x Source #
Instance details Defined in Type.Data.Num type IsOdd x = Not (IsEven x)

isOdd :: Proxy x -> Proxy (IsOdd x) Source #

type family x :+: y Source #

Instances

type (Un x) :+: (Un y) Source #
Instance details Defined in Type.Data.Num.Unary type (Un x) :+: (Un y) = Un (x :+: y)
type (Dec x) :+: (Dec y) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type (Dec x) :+: (Dec y) = Dec (x :+: y)

add :: Proxy x -> Proxy y -> Proxy (x :+: y) Source #

type family x :-: y Source #

Instances

type (Dec x) :-: (Dec y) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type (Dec x) :-: (Dec y) = Dec (x :-: y)

sub :: Proxy x -> Proxy y -> Proxy (x :-: y) Source #

type family x :*: y Source #

Instances

type (Un x) :*: (Un y) Source #
Instance details Defined in Type.Data.Num.Unary type (Un x) :: (Un y) = Un (x :: y)
type (Dec x) :*: (Dec y) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type (Dec x) :: (Dec y) = Dec (x :: y)

mul :: Proxy x -> Proxy y -> Proxy (x :*: y) Source #

type family Mul2 x Source #

Instances

type Mul2 (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type Mul2 (Dec x) = Dec (x :+: x)

mul2 :: Proxy x -> Proxy (Mul2 x) Source #

type family Pow2 x Source #

Instances

type Pow2 (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type Pow2 (Dec x) = Dec (Pow2 x)

pow2 :: Proxy x -> Proxy (Pow2 x) Source #

type family Log2Ceil x Source #

Instances

type Log2Ceil (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type Log2Ceil (Dec x) = Dec (Log2Ceil x)

log2Ceil :: Proxy x -> Proxy (Log2Ceil x) Source #

type family DivMod x y Source #

divMod :: Proxy x -> Proxy y -> Proxy (DivMod x y) Source #

type family Div x y Source #

div :: Proxy x -> Proxy y -> Proxy (Div x y) Source #

type family Mod x y Source #

mod :: Proxy x -> Proxy y -> Proxy (Mod x y) Source #

type family Div2 x Source #

Instances

type Div2 (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number type Div2 (Dec x)

div2 :: Proxy x -> Proxy (Div2 x) Source #

type family Fac x Source #

Instances

type Fac x Source #
Instance details Defined in Type.Data.Num type Fac x

fac :: Proxy x -> Proxy (Fac x) Source #

newtype Singleton d Source #

Constructors

Singleton Integer

class Representation r where Source #

Methods

reifyIntegral :: Proxy r -> Integer -> (forall s. (Integer s, Repr s ~ r) => Proxy s -> a) -> a Source #

Instances

Representation Unary Source #
Instance details Defined in Type.Data.Num.Unary Methods reifyIntegral :: Proxy Unary -> Integer -> (forall s. (Integer s, Repr s ~ Unary) => Proxy s -> a) -> a Source #
Representation Decimal Source #
Instance details Defined in Type.Data.Num.Decimal.Number Methods reifyIntegral :: Proxy Decimal -> Integer -> (forall s. (Integer s, Repr s ~ Decimal) => Proxy s -> a) -> a Source #

class Representation (Repr x) => Integer x where Source #

Associated Types

type Repr x Source #

Methods

singleton :: Singleton x Source #

Instances

Natural n => Integer (Un n) Source #
Instance details Defined in Type.Data.Num.Unary Associated Types type Repr (Un n) :: Type Source # Methods singleton :: Singleton (Un n) Source #
Integer x => Integer (Dec x) Source #
Instance details Defined in Type.Data.Num.Decimal.Number Associated Types type Repr (Dec x) :: Type Source # Methods singleton :: Singleton (Dec x) Source #

class Integer x => Natural x Source #

Instances

(Integer x, IsNatural x ~ True) => Natural x Source #
Instance details Defined in Type.Data.Num

class Integer x => Positive x Source #

Instances

(Integer x, IsPositive x ~ True) => Positive x Source #
Instance details Defined in Type.Data.Num

class Integer x => Negative x Source #

Instances

(Integer x, IsNegative x ~ True) => Negative x Source #
Instance details Defined in Type.Data.Num

integerFromSingleton :: Integer x => Singleton x -> Integer Source #

integralFromSingleton :: (Integer x, Num y) => Singleton x -> y Source #

singletonFromProxy :: Integer x => Proxy x -> Singleton x Source #

integralFromProxy :: (Integer x, Num y) => Proxy x -> y Source #

fromInteger :: (Integer x, Num y) => Proxy x -> y Source #

synonym for integralFromProxy, kept for backward compatibility

reifyPositive :: Representation r => Proxy r -> Integer -> (forall s. (Positive s, Repr s ~ r) => Proxy s -> a) -> Maybe a Source #

reifyNegative :: Representation r => Proxy r -> Integer -> (forall s. (Negative s, Repr s ~ r) => Proxy s -> a) -> Maybe a Source #

reifyNatural :: Representation r => Proxy r -> Integer -> (forall s. (Natural s, Repr s ~ r) => Proxy s -> a) -> Maybe a Source #