singletons-2.3.1: A framework for generating singleton types

Copyright(C) 2014 Jan Stolarek
LicenseBSD-style (see LICENSE)
MaintainerJan Stolarek (jan.stolarek@p.lodz.pl)
Stabilityexperimental
Portabilitynon-portable
Safe HaskellNone
LanguageHaskell2010

Data.Promotion.Prelude.Ord

Description

Provides promoted definitions related to type-level comparisons.

Documentation

class PEq a => POrd (a :: Type) #

Associated Types

type Compare (arg :: a) (arg :: a) :: Ordering #

type (arg :: a) :< (arg :: a) :: Bool infix 4 #

type (arg :: a) :<= (arg :: a) :: Bool infix 4 #

type (arg :: a) :> (arg :: a) :: Bool infix 4 #

type (arg :: a) :>= (arg :: a) :: Bool infix 4 #

type Max (arg :: a) (arg :: a) :: a #

type Min (arg :: a) (arg :: a) :: a #

Instances

POrd Bool # 

Associated Types

type Compare Bool (arg :: Bool) (arg :: Bool) :: Ordering #

type (Bool :< (arg :: Bool)) (arg :: Bool) :: Bool #

type (Bool :<= (arg :: Bool)) (arg :: Bool) :: Bool #

type (Bool :> (arg :: Bool)) (arg :: Bool) :: Bool #

type (Bool :>= (arg :: Bool)) (arg :: Bool) :: Bool #

type Max Bool (arg :: Bool) (arg :: Bool) :: a #

type Min Bool (arg :: Bool) (arg :: Bool) :: a #

POrd Ordering # 

Associated Types

type Compare Ordering (arg :: Ordering) (arg :: Ordering) :: Ordering #

type (Ordering :< (arg :: Ordering)) (arg :: Ordering) :: Bool #

type (Ordering :<= (arg :: Ordering)) (arg :: Ordering) :: Bool #

type (Ordering :> (arg :: Ordering)) (arg :: Ordering) :: Bool #

type (Ordering :>= (arg :: Ordering)) (arg :: Ordering) :: Bool #

type Max Ordering (arg :: Ordering) (arg :: Ordering) :: a #

type Min Ordering (arg :: Ordering) (arg :: Ordering) :: a #

POrd () # 

Associated Types

type Compare () (arg :: ()) (arg :: ()) :: Ordering #

type (() :< (arg :: ())) (arg :: ()) :: Bool #

type (() :<= (arg :: ())) (arg :: ()) :: Bool #

type (() :> (arg :: ())) (arg :: ()) :: Bool #

type (() :>= (arg :: ())) (arg :: ()) :: Bool #

type Max () (arg :: ()) (arg :: ()) :: a #

type Min () (arg :: ()) (arg :: ()) :: a #

POrd [a] # 

Associated Types

type Compare [a] (arg :: [a]) (arg :: [a]) :: Ordering #

type ([a] :< (arg :: [a])) (arg :: [a]) :: Bool #

type ([a] :<= (arg :: [a])) (arg :: [a]) :: Bool #

type ([a] :> (arg :: [a])) (arg :: [a]) :: Bool #

type ([a] :>= (arg :: [a])) (arg :: [a]) :: Bool #

type Max [a] (arg :: [a]) (arg :: [a]) :: a #

type Min [a] (arg :: [a]) (arg :: [a]) :: a #

POrd (Maybe a) # 

Associated Types

type Compare (Maybe a) (arg :: Maybe a) (arg :: Maybe a) :: Ordering #

type ((Maybe a) :< (arg :: Maybe a)) (arg :: Maybe a) :: Bool #

type ((Maybe a) :<= (arg :: Maybe a)) (arg :: Maybe a) :: Bool #

type ((Maybe a) :> (arg :: Maybe a)) (arg :: Maybe a) :: Bool #

type ((Maybe a) :>= (arg :: Maybe a)) (arg :: Maybe a) :: Bool #

type Max (Maybe a) (arg :: Maybe a) (arg :: Maybe a) :: a #

type Min (Maybe a) (arg :: Maybe a) (arg :: Maybe a) :: a #

POrd (NonEmpty a) # 

Associated Types

type Compare (NonEmpty a) (arg :: NonEmpty a) (arg :: NonEmpty a) :: Ordering #

type ((NonEmpty a) :< (arg :: NonEmpty a)) (arg :: NonEmpty a) :: Bool #

type ((NonEmpty a) :<= (arg :: NonEmpty a)) (arg :: NonEmpty a) :: Bool #

type ((NonEmpty a) :> (arg :: NonEmpty a)) (arg :: NonEmpty a) :: Bool #

type ((NonEmpty a) :>= (arg :: NonEmpty a)) (arg :: NonEmpty a) :: Bool #

type Max (NonEmpty a) (arg :: NonEmpty a) (arg :: NonEmpty a) :: a #

type Min (NonEmpty a) (arg :: NonEmpty a) (arg :: NonEmpty a) :: a #

POrd (Either a b) # 

Associated Types

type Compare (Either a b) (arg :: Either a b) (arg :: Either a b) :: Ordering #

type ((Either a b) :< (arg :: Either a b)) (arg :: Either a b) :: Bool #

type ((Either a b) :<= (arg :: Either a b)) (arg :: Either a b) :: Bool #

type ((Either a b) :> (arg :: Either a b)) (arg :: Either a b) :: Bool #

type ((Either a b) :>= (arg :: Either a b)) (arg :: Either a b) :: Bool #

type Max (Either a b) (arg :: Either a b) (arg :: Either a b) :: a #

type Min (Either a b) (arg :: Either a b) (arg :: Either a b) :: a #

POrd (a, b) # 

Associated Types

type Compare (a, b) (arg :: (a, b)) (arg :: (a, b)) :: Ordering #

type ((a, b) :< (arg :: (a, b))) (arg :: (a, b)) :: Bool #

type ((a, b) :<= (arg :: (a, b))) (arg :: (a, b)) :: Bool #

type ((a, b) :> (arg :: (a, b))) (arg :: (a, b)) :: Bool #

type ((a, b) :>= (arg :: (a, b))) (arg :: (a, b)) :: Bool #

type Max (a, b) (arg :: (a, b)) (arg :: (a, b)) :: a #

type Min (a, b) (arg :: (a, b)) (arg :: (a, b)) :: a #

POrd (a, b, c) # 

Associated Types

type Compare (a, b, c) (arg :: (a, b, c)) (arg :: (a, b, c)) :: Ordering #

type ((a, b, c) :< (arg :: (a, b, c))) (arg :: (a, b, c)) :: Bool #

type ((a, b, c) :<= (arg :: (a, b, c))) (arg :: (a, b, c)) :: Bool #

type ((a, b, c) :> (arg :: (a, b, c))) (arg :: (a, b, c)) :: Bool #

type ((a, b, c) :>= (arg :: (a, b, c))) (arg :: (a, b, c)) :: Bool #

type Max (a, b, c) (arg :: (a, b, c)) (arg :: (a, b, c)) :: a #

type Min (a, b, c) (arg :: (a, b, c)) (arg :: (a, b, c)) :: a #

POrd (a, b, c, d) # 

Associated Types

type Compare (a, b, c, d) (arg :: (a, b, c, d)) (arg :: (a, b, c, d)) :: Ordering #

type ((a, b, c, d) :< (arg :: (a, b, c, d))) (arg :: (a, b, c, d)) :: Bool #

type ((a, b, c, d) :<= (arg :: (a, b, c, d))) (arg :: (a, b, c, d)) :: Bool #

type ((a, b, c, d) :> (arg :: (a, b, c, d))) (arg :: (a, b, c, d)) :: Bool #

type ((a, b, c, d) :>= (arg :: (a, b, c, d))) (arg :: (a, b, c, d)) :: Bool #

type Max (a, b, c, d) (arg :: (a, b, c, d)) (arg :: (a, b, c, d)) :: a #

type Min (a, b, c, d) (arg :: (a, b, c, d)) (arg :: (a, b, c, d)) :: a #

POrd (a, b, c, d, e) # 

Associated Types

type Compare (a, b, c, d, e) (arg :: (a, b, c, d, e)) (arg :: (a, b, c, d, e)) :: Ordering #

type ((a, b, c, d, e) :< (arg :: (a, b, c, d, e))) (arg :: (a, b, c, d, e)) :: Bool #

type ((a, b, c, d, e) :<= (arg :: (a, b, c, d, e))) (arg :: (a, b, c, d, e)) :: Bool #

type ((a, b, c, d, e) :> (arg :: (a, b, c, d, e))) (arg :: (a, b, c, d, e)) :: Bool #

type ((a, b, c, d, e) :>= (arg :: (a, b, c, d, e))) (arg :: (a, b, c, d, e)) :: Bool #

type Max (a, b, c, d, e) (arg :: (a, b, c, d, e)) (arg :: (a, b, c, d, e)) :: a #

type Min (a, b, c, d, e) (arg :: (a, b, c, d, e)) (arg :: (a, b, c, d, e)) :: a #

POrd (a, b, c, d, e, f) # 

Associated Types

type Compare (a, b, c, d, e, f) (arg :: (a, b, c, d, e, f)) (arg :: (a, b, c, d, e, f)) :: Ordering #

type ((a, b, c, d, e, f) :< (arg :: (a, b, c, d, e, f))) (arg :: (a, b, c, d, e, f)) :: Bool #

type ((a, b, c, d, e, f) :<= (arg :: (a, b, c, d, e, f))) (arg :: (a, b, c, d, e, f)) :: Bool #

type ((a, b, c, d, e, f) :> (arg :: (a, b, c, d, e, f))) (arg :: (a, b, c, d, e, f)) :: Bool #

type ((a, b, c, d, e, f) :>= (arg :: (a, b, c, d, e, f))) (arg :: (a, b, c, d, e, f)) :: Bool #

type Max (a, b, c, d, e, f) (arg :: (a, b, c, d, e, f)) (arg :: (a, b, c, d, e, f)) :: a #

type Min (a, b, c, d, e, f) (arg :: (a, b, c, d, e, f)) (arg :: (a, b, c, d, e, f)) :: a #

POrd (a, b, c, d, e, f, g) # 

Associated Types

type Compare (a, b, c, d, e, f, g) (arg :: (a, b, c, d, e, f, g)) (arg :: (a, b, c, d, e, f, g)) :: Ordering #

type ((a, b, c, d, e, f, g) :< (arg :: (a, b, c, d, e, f, g))) (arg :: (a, b, c, d, e, f, g)) :: Bool #

type ((a, b, c, d, e, f, g) :<= (arg :: (a, b, c, d, e, f, g))) (arg :: (a, b, c, d, e, f, g)) :: Bool #

type ((a, b, c, d, e, f, g) :> (arg :: (a, b, c, d, e, f, g))) (arg :: (a, b, c, d, e, f, g)) :: Bool #

type ((a, b, c, d, e, f, g) :>= (arg :: (a, b, c, d, e, f, g))) (arg :: (a, b, c, d, e, f, g)) :: Bool #

type Max (a, b, c, d, e, f, g) (arg :: (a, b, c, d, e, f, g)) (arg :: (a, b, c, d, e, f, g)) :: a #

type Min (a, b, c, d, e, f, g) (arg :: (a, b, c, d, e, f, g)) (arg :: (a, b, c, d, e, f, g)) :: a #

type LTSym0 = LT #

type EQSym0 = EQ #

type GTSym0 = GT #

data CompareSym0 (l :: TyFun a6989586621679269814 (TyFun a6989586621679269814 Ordering -> Type)) #

Instances

SuppressUnusedWarnings (TyFun a6989586621679269814 (TyFun a6989586621679269814 Ordering -> Type) -> *) (CompareSym0 a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy (CompareSym0 a6989586621679269814) t -> () #

type Apply a6989586621679269814 (TyFun a6989586621679269814 Ordering -> Type) (CompareSym0 a6989586621679269814) l # 
type Apply a6989586621679269814 (TyFun a6989586621679269814 Ordering -> Type) (CompareSym0 a6989586621679269814) l = CompareSym1 a6989586621679269814 l

data CompareSym1 (l :: a6989586621679269814) (l :: TyFun a6989586621679269814 Ordering) #

Instances

SuppressUnusedWarnings (a6989586621679269814 -> TyFun a6989586621679269814 Ordering -> *) (CompareSym1 a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy (CompareSym1 a6989586621679269814) t -> () #

type Apply a Ordering (CompareSym1 a l1) l2 # 
type Apply a Ordering (CompareSym1 a l1) l2 = Compare a l1 l2

type CompareSym2 (t :: a6989586621679269814) (t :: a6989586621679269814) = Compare t t #

data (:<$) (l :: TyFun a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type)) #

Instances

SuppressUnusedWarnings (TyFun a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) -> *) ((:<$) a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy ((:<$) a6989586621679269814) t -> () #

type Apply a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) ((:<$) a6989586621679269814) l # 
type Apply a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) ((:<$) a6989586621679269814) l = (:<$$) a6989586621679269814 l

data (l :: a6989586621679269814) :<$$ (l :: TyFun a6989586621679269814 Bool) #

Instances

SuppressUnusedWarnings (a6989586621679269814 -> TyFun a6989586621679269814 Bool -> *) ((:<$$) a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy ((:<$$) a6989586621679269814) t -> () #

type Apply a Bool ((:<$$) a l1) l2 # 
type Apply a Bool ((:<$$) a l1) l2 = (:<) a l1 l2

type (:<$$$) (t :: a6989586621679269814) (t :: a6989586621679269814) = (:<) t t #

data (:<=$) (l :: TyFun a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type)) #

Instances

SuppressUnusedWarnings (TyFun a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) -> *) ((:<=$) a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy ((:<=$) a6989586621679269814) t -> () #

type Apply a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) ((:<=$) a6989586621679269814) l # 
type Apply a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) ((:<=$) a6989586621679269814) l = (:<=$$) a6989586621679269814 l

data (l :: a6989586621679269814) :<=$$ (l :: TyFun a6989586621679269814 Bool) #

Instances

SuppressUnusedWarnings (a6989586621679269814 -> TyFun a6989586621679269814 Bool -> *) ((:<=$$) a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy ((:<=$$) a6989586621679269814) t -> () #

type Apply a Bool ((:<=$$) a l1) l2 # 
type Apply a Bool ((:<=$$) a l1) l2 = (:<=) a l1 l2

type (:<=$$$) (t :: a6989586621679269814) (t :: a6989586621679269814) = (:<=) t t #

data (:>$) (l :: TyFun a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type)) #

Instances

SuppressUnusedWarnings (TyFun a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) -> *) ((:>$) a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy ((:>$) a6989586621679269814) t -> () #

type Apply a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) ((:>$) a6989586621679269814) l # 
type Apply a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) ((:>$) a6989586621679269814) l = (:>$$) a6989586621679269814 l

data (l :: a6989586621679269814) :>$$ (l :: TyFun a6989586621679269814 Bool) #

Instances

SuppressUnusedWarnings (a6989586621679269814 -> TyFun a6989586621679269814 Bool -> *) ((:>$$) a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy ((:>$$) a6989586621679269814) t -> () #

type Apply a Bool ((:>$$) a l1) l2 # 
type Apply a Bool ((:>$$) a l1) l2 = (:>) a l1 l2

type (:>$$$) (t :: a6989586621679269814) (t :: a6989586621679269814) = (:>) t t #

data (:>=$) (l :: TyFun a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type)) #

Instances

SuppressUnusedWarnings (TyFun a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) -> *) ((:>=$) a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy ((:>=$) a6989586621679269814) t -> () #

type Apply a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) ((:>=$) a6989586621679269814) l # 
type Apply a6989586621679269814 (TyFun a6989586621679269814 Bool -> Type) ((:>=$) a6989586621679269814) l = (:>=$$) a6989586621679269814 l

data (l :: a6989586621679269814) :>=$$ (l :: TyFun a6989586621679269814 Bool) #

Instances

SuppressUnusedWarnings (a6989586621679269814 -> TyFun a6989586621679269814 Bool -> *) ((:>=$$) a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy ((:>=$$) a6989586621679269814) t -> () #

type Apply a Bool ((:>=$$) a l1) l2 # 
type Apply a Bool ((:>=$$) a l1) l2 = (:>=) a l1 l2

type (:>=$$$) (t :: a6989586621679269814) (t :: a6989586621679269814) = (:>=) t t #

data MaxSym0 (l :: TyFun a6989586621679269814 (TyFun a6989586621679269814 a6989586621679269814 -> Type)) #

Instances

SuppressUnusedWarnings (TyFun a6989586621679269814 (TyFun a6989586621679269814 a6989586621679269814 -> Type) -> *) (MaxSym0 a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy (MaxSym0 a6989586621679269814) t -> () #

type Apply a6989586621679269814 (TyFun a6989586621679269814 a6989586621679269814 -> Type) (MaxSym0 a6989586621679269814) l # 
type Apply a6989586621679269814 (TyFun a6989586621679269814 a6989586621679269814 -> Type) (MaxSym0 a6989586621679269814) l = MaxSym1 a6989586621679269814 l

data MaxSym1 (l :: a6989586621679269814) (l :: TyFun a6989586621679269814 a6989586621679269814) #

Instances

SuppressUnusedWarnings (a6989586621679269814 -> TyFun a6989586621679269814 a6989586621679269814 -> *) (MaxSym1 a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy (MaxSym1 a6989586621679269814) t -> () #

type Apply a a (MaxSym1 a l1) l2 # 
type Apply a a (MaxSym1 a l1) l2 = Max a l1 l2

type MaxSym2 (t :: a6989586621679269814) (t :: a6989586621679269814) = Max t t #

data MinSym0 (l :: TyFun a6989586621679269814 (TyFun a6989586621679269814 a6989586621679269814 -> Type)) #

Instances

SuppressUnusedWarnings (TyFun a6989586621679269814 (TyFun a6989586621679269814 a6989586621679269814 -> Type) -> *) (MinSym0 a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy (MinSym0 a6989586621679269814) t -> () #

type Apply a6989586621679269814 (TyFun a6989586621679269814 a6989586621679269814 -> Type) (MinSym0 a6989586621679269814) l # 
type Apply a6989586621679269814 (TyFun a6989586621679269814 a6989586621679269814 -> Type) (MinSym0 a6989586621679269814) l = MinSym1 a6989586621679269814 l

data MinSym1 (l :: a6989586621679269814) (l :: TyFun a6989586621679269814 a6989586621679269814) #

Instances

SuppressUnusedWarnings (a6989586621679269814 -> TyFun a6989586621679269814 a6989586621679269814 -> *) (MinSym1 a6989586621679269814) # 

Methods

suppressUnusedWarnings :: Proxy (MinSym1 a6989586621679269814) t -> () #

type Apply a a (MinSym1 a l1) l2 # 
type Apply a a (MinSym1 a l1) l2 = Min a l1 l2

type MinSym2 (t :: a6989586621679269814) (t :: a6989586621679269814) = Min t t #