tfp-1.0.0.2: Type-level integers, booleans, lists using type families

Safe HaskellSafe
LanguageHaskell2010

Type.Data.Ord

Documentation

type family Compare x y #

Instances

type Compare False False # 
type Compare False True # 
type Compare True False # 
type Compare True True # 
type Compare GT GT # 
type Compare GT GT = EQ
type Compare GT EQ # 
type Compare GT EQ = GT
type Compare GT LT # 
type Compare GT LT = GT
type Compare EQ GT # 
type Compare EQ GT = LT
type Compare EQ EQ # 
type Compare EQ EQ = EQ
type Compare EQ LT # 
type Compare EQ LT = GT
type Compare LT GT # 
type Compare LT GT = LT
type Compare LT EQ # 
type Compare LT EQ = LT
type Compare LT LT # 
type Compare LT LT = EQ
type Compare (Dec x) (Dec y) # 
type Compare (Dec x) (Dec y) = Compare x y

compare :: Proxy x -> Proxy y -> Proxy (Compare x y) #

data LT #

Instances

type IsGT LT # 
type IsGT LT = False
type IsEQ LT # 
type IsEQ LT = False
type IsLT LT # 
type IsLT LT = True
type Compare GT LT # 
type Compare GT LT = GT
type Compare EQ LT # 
type Compare EQ LT = GT
type Compare LT GT # 
type Compare LT GT = LT
type Compare LT EQ # 
type Compare LT EQ = LT
type Compare LT LT # 
type Compare LT LT = EQ

data EQ #

Instances

type IsGT EQ # 
type IsGT EQ = False
type IsEQ EQ # 
type IsEQ EQ = True
type IsLT EQ # 
type IsLT EQ = False
type Compare GT EQ # 
type Compare GT EQ = GT
type Compare EQ GT # 
type Compare EQ GT = LT
type Compare EQ EQ # 
type Compare EQ EQ = EQ
type Compare EQ LT # 
type Compare EQ LT = GT
type Compare LT EQ # 
type Compare LT EQ = LT

data GT #

Instances

type IsGT GT # 
type IsGT GT = True
type IsEQ GT # 
type IsEQ GT = False
type IsLT GT # 
type IsLT GT = False
type Compare GT GT # 
type Compare GT GT = EQ
type Compare GT EQ # 
type Compare GT EQ = GT
type Compare GT LT # 
type Compare GT LT = GT
type Compare EQ GT # 
type Compare EQ GT = LT
type Compare LT GT # 
type Compare LT GT = LT

type family IsLT c #

Instances

type IsLT GT # 
type IsLT GT = False
type IsLT EQ # 
type IsLT EQ = False
type IsLT LT # 
type IsLT LT = True

isLT :: Proxy c -> Proxy (IsLT c) #

type family IsEQ c #

Instances

type IsEQ GT # 
type IsEQ GT = False
type IsEQ EQ # 
type IsEQ EQ = True
type IsEQ LT # 
type IsEQ LT = False

isEQ :: Proxy c -> Proxy (IsEQ c) #

type family IsGT c #

Instances

type IsGT GT # 
type IsGT GT = True
type IsGT EQ # 
type IsGT EQ = False
type IsGT LT # 
type IsGT LT = False

isGT :: Proxy c -> Proxy (IsGT c) #

class x :<: y #

lt :: Proxy x -> Proxy y -> Proxy (LTT x y) #

type family LTT x y #

Instances

type LTT x y # 
type LTT x y = IsLT (Compare x y)

class x :<=: y #

le :: Proxy x -> Proxy y -> Proxy (LET x y) #

type family LET x y #

Instances

type LET x y # 
type LET x y = Not (GTT x y)

class x :==: y #

eq :: Proxy x -> Proxy y -> Proxy (EQT x y) #

type family EQT x y #

Instances

type EQT x y # 
type EQT x y = IsEQ (Compare x y)

class x :/=: y #

ne :: Proxy x -> Proxy y -> Proxy (NET x y) #

type family NET x y #

Instances

type NET x y # 
type NET x y = Not (EQT x y)

class x :>=: y #

ge :: Proxy x -> Proxy y -> Proxy (GET x y) #

type family GET x y #

Instances

type GET x y # 
type GET x y = Not (LTT x y)

class x :>: y #

gt :: Proxy x -> Proxy y -> Proxy (GTT x y) #

type family GTT x y #

Instances

type GTT x y # 
type GTT x y = IsGT (Compare x y)

type family Min x y #

Instances

type Min x y # 
type Min x y = If (LET x y) x y

min :: Proxy x -> Proxy y -> Proxy (Min x y) #

type family Max x y #

Instances

type Max x y # 
type Max x y = If (GET x y) x y

max :: Proxy x -> Proxy y -> Proxy (Max x y) #