Data.Singletons.Prelude.Ord

Defines the promoted version of Ord, POrd, and the singleton version, SOrd.

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

class SEq a => SOrd a where

Methods

sCompare :: forall (t :: a) (t :: a). Sing t -> Sing t -> Sing (Apply (Apply CompareSym0 t) t :: Ordering)

(%:<) :: forall (t :: a) (t :: a). Sing t -> Sing t -> Sing (Apply (Apply (:<$) t) t :: Bool) infix 4

(%:<=) :: forall (t :: a) (t :: a). Sing t -> Sing t -> Sing (Apply (Apply (:<=$) t) t :: Bool) infix 4

(%:>) :: forall (t :: a) (t :: a). Sing t -> Sing t -> Sing (Apply (Apply (:>$) t) t :: Bool) infix 4

(%:>=) :: forall (t :: a) (t :: a). Sing t -> Sing t -> Sing (Apply (Apply (:>=$) t) t :: Bool) infix 4

sMax :: forall (t :: a) (t :: a). Sing t -> Sing t -> Sing (Apply (Apply MaxSym0 t) t :: a)

sMin :: forall (t :: a) (t :: a). Sing t -> Sing t -> Sing (Apply (Apply MinSym0 t) t :: a)

sCompare :: forall (t :: a) (t :: a). ((Apply (Apply CompareSym0 t) t :: Ordering) ~ Apply (Apply Compare_6989586621679313968Sym0 t) t) => Sing t -> Sing t -> Sing (Apply (Apply CompareSym0 t) t :: Ordering)

(%:<) :: forall (t :: a) (t :: a). ((Apply (Apply (:<$) t) t :: Bool) ~ Apply (Apply TFHelper_6989586621679314001Sym0 t) t) => Sing t -> Sing t -> Sing (Apply (Apply (:<$) t) t :: Bool) infix 4

(%:<=) :: forall (t :: a) (t :: a). ((Apply (Apply (:<=$) t) t :: Bool) ~ Apply (Apply TFHelper_6989586621679314034Sym0 t) t) => Sing t -> Sing t -> Sing (Apply (Apply (:<=$) t) t :: Bool) infix 4

(%:>) :: forall (t :: a) (t :: a). ((Apply (Apply (:>$) t) t :: Bool) ~ Apply (Apply TFHelper_6989586621679314067Sym0 t) t) => Sing t -> Sing t -> Sing (Apply (Apply (:>$) t) t :: Bool) infix 4

(%:>=) :: forall (t :: a) (t :: a). ((Apply (Apply (:>=$) t) t :: Bool) ~ Apply (Apply TFHelper_6989586621679314100Sym0 t) t) => Sing t -> Sing t -> Sing (Apply (Apply (:>=$) t) t :: Bool) infix 4

sMax :: forall (t :: a) (t :: a). ((Apply (Apply MaxSym0 t) t :: a) ~ Apply (Apply Max_6989586621679314133Sym0 t) t) => Sing t -> Sing t -> Sing (Apply (Apply MaxSym0 t) t :: a)

sMin :: forall (t :: a) (t :: a). ((Apply (Apply MinSym0 t) t :: a) ~ Apply (Apply Min_6989586621679314166Sym0 t) t) => Sing t -> Sing t -> Sing (Apply (Apply MinSym0 t) t :: a)

Instances

SOrd Bool

Methods

sCompare :: Sing Bool t -> Sing Bool t -> Sing Ordering (Apply Bool Ordering (Apply Bool (TyFun Bool Ordering -> Type) (CompareSym0 Bool) t) t)

(%:<) :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) ((:<$) Bool) t) t)

(%:<=) :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) ((:<=$) Bool) t) t)

(%:>) :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) ((:>$) Bool) t) t)

(%:>=) :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) ((:>=$) Bool) t) t)

sMax :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) (MaxSym0 Bool) t) t)

sMin :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) (MinSym0 Bool) t) t)

SOrd Ordering

Methods

sCompare :: Sing Ordering t -> Sing Ordering t -> Sing Ordering (Apply Ordering Ordering (Apply Ordering (TyFun Ordering Ordering -> Type) (CompareSym0 Ordering) t) t)

(%:<) :: Sing Ordering t -> Sing Ordering t -> Sing Bool (Apply Ordering Bool (Apply Ordering (TyFun Ordering Bool -> Type) ((:<$) Ordering) t) t)

(%:<=) :: Sing Ordering t -> Sing Ordering t -> Sing Bool (Apply Ordering Bool (Apply Ordering (TyFun Ordering Bool -> Type) ((:<=$) Ordering) t) t)

(%:>) :: Sing Ordering t -> Sing Ordering t -> Sing Bool (Apply Ordering Bool (Apply Ordering (TyFun Ordering Bool -> Type) ((:>$) Ordering) t) t)

(%:>=) :: Sing Ordering t -> Sing Ordering t -> Sing Bool (Apply Ordering Bool (Apply Ordering (TyFun Ordering Bool -> Type) ((:>=$) Ordering) t) t)

sMax :: Sing Ordering t -> Sing Ordering t -> Sing Ordering (Apply Ordering Ordering (Apply Ordering (TyFun Ordering Ordering -> Type) (MaxSym0 Ordering) t) t)

sMin :: Sing Ordering t -> Sing Ordering t -> Sing Ordering (Apply Ordering Ordering (Apply Ordering (TyFun Ordering Ordering -> Type) (MinSym0 Ordering) t) t)

SOrd ()

Methods

sCompare :: Sing () t -> Sing () t -> Sing Ordering (Apply () Ordering (Apply () (TyFun () Ordering -> Type) (CompareSym0 ()) t) t)

(%:<) :: Sing () t -> Sing () t -> Sing Bool (Apply () Bool (Apply () (TyFun () Bool -> Type) ((:<$) ()) t) t)

(%:<=) :: Sing () t -> Sing () t -> Sing Bool (Apply () Bool (Apply () (TyFun () Bool -> Type) ((:<=$) ()) t) t)

(%:>) :: Sing () t -> Sing () t -> Sing Bool (Apply () Bool (Apply () (TyFun () Bool -> Type) ((:>$) ()) t) t)

(%:>=) :: Sing () t -> Sing () t -> Sing Bool (Apply () Bool (Apply () (TyFun () Bool -> Type) ((:>=$) ()) t) t)

sMax :: Sing () t -> Sing () t -> Sing () (Apply () () (Apply () (TyFun () () -> Type) (MaxSym0 ()) t) t)

sMin :: Sing () t -> Sing () t -> Sing () (Apply () () (Apply () (TyFun () () -> Type) (MinSym0 ()) t) t)

(SOrd a, SOrd [a]) => SOrd [a]

Methods

sCompare :: Sing [a] t -> Sing [a] t -> Sing Ordering (Apply [a] Ordering (Apply [a] (TyFun [a] Ordering -> Type) (CompareSym0 [a]) t) t)

(%:<) :: Sing [a] t -> Sing [a] t -> Sing Bool (Apply [a] Bool (Apply [a] (TyFun [a] Bool -> Type) ((:<$) [a]) t) t)

(%:<=) :: Sing [a] t -> Sing [a] t -> Sing Bool (Apply [a] Bool (Apply [a] (TyFun [a] Bool -> Type) ((:<=$) [a]) t) t)

(%:>) :: Sing [a] t -> Sing [a] t -> Sing Bool (Apply [a] Bool (Apply [a] (TyFun [a] Bool -> Type) ((:>$) [a]) t) t)

(%:>=) :: Sing [a] t -> Sing [a] t -> Sing Bool (Apply [a] Bool (Apply [a] (TyFun [a] Bool -> Type) ((:>=$) [a]) t) t)

sMax :: Sing [a] t -> Sing [a] t -> Sing [a] (Apply [a] [a] (Apply [a] (TyFun [a] [a] -> Type) (MaxSym0 [a]) t) t)

sMin :: Sing [a] t -> Sing [a] t -> Sing [a] (Apply [a] [a] (Apply [a] (TyFun [a] [a] -> Type) (MinSym0 [a]) t) t)

SOrd a => SOrd (Maybe a)

Methods

sCompare :: Sing (Maybe a) t -> Sing (Maybe a) t -> Sing Ordering (Apply (Maybe a) Ordering (Apply (Maybe a) (TyFun (Maybe a) Ordering -> Type) (CompareSym0 (Maybe a)) t) t)

(%:<) :: Sing (Maybe a) t -> Sing (Maybe a) t -> Sing Bool (Apply (Maybe a) Bool (Apply (Maybe a) (TyFun (Maybe a) Bool -> Type) ((:<$) (Maybe a)) t) t)

(%:<=) :: Sing (Maybe a) t -> Sing (Maybe a) t -> Sing Bool (Apply (Maybe a) Bool (Apply (Maybe a) (TyFun (Maybe a) Bool -> Type) ((:<=$) (Maybe a)) t) t)

(%:>) :: Sing (Maybe a) t -> Sing (Maybe a) t -> Sing Bool (Apply (Maybe a) Bool (Apply (Maybe a) (TyFun (Maybe a) Bool -> Type) ((:>$) (Maybe a)) t) t)

(%:>=) :: Sing (Maybe a) t -> Sing (Maybe a) t -> Sing Bool (Apply (Maybe a) Bool (Apply (Maybe a) (TyFun (Maybe a) Bool -> Type) ((:>=$) (Maybe a)) t) t)

sMax :: Sing (Maybe a) t -> Sing (Maybe a) t -> Sing (Maybe a) (Apply (Maybe a) (Maybe a) (Apply (Maybe a) (TyFun (Maybe a) (Maybe a) -> Type) (MaxSym0 (Maybe a)) t) t)

sMin :: Sing (Maybe a) t -> Sing (Maybe a) t -> Sing (Maybe a) (Apply (Maybe a) (Maybe a) (Apply (Maybe a) (TyFun (Maybe a) (Maybe a) -> Type) (MinSym0 (Maybe a)) t) t)

(SOrd a, SOrd [a]) => SOrd (NonEmpty a)

Methods

sCompare :: Sing (NonEmpty a) t -> Sing (NonEmpty a) t -> Sing Ordering (Apply (NonEmpty a) Ordering (Apply (NonEmpty a) (TyFun (NonEmpty a) Ordering -> Type) (CompareSym0 (NonEmpty a)) t) t)

(%:<) :: Sing (NonEmpty a) t -> Sing (NonEmpty a) t -> Sing Bool (Apply (NonEmpty a) Bool (Apply (NonEmpty a) (TyFun (NonEmpty a) Bool -> Type) ((:<$) (NonEmpty a)) t) t)

(%:<=) :: Sing (NonEmpty a) t -> Sing (NonEmpty a) t -> Sing Bool (Apply (NonEmpty a) Bool (Apply (NonEmpty a) (TyFun (NonEmpty a) Bool -> Type) ((:<=$) (NonEmpty a)) t) t)

(%:>) :: Sing (NonEmpty a) t -> Sing (NonEmpty a) t -> Sing Bool (Apply (NonEmpty a) Bool (Apply (NonEmpty a) (TyFun (NonEmpty a) Bool -> Type) ((:>$) (NonEmpty a)) t) t)

(%:>=) :: Sing (NonEmpty a) t -> Sing (NonEmpty a) t -> Sing Bool (Apply (NonEmpty a) Bool (Apply (NonEmpty a) (TyFun (NonEmpty a) Bool -> Type) ((:>=$) (NonEmpty a)) t) t)

sMax :: Sing (NonEmpty a) t -> Sing (NonEmpty a) t -> Sing (NonEmpty a) (Apply (NonEmpty a) (NonEmpty a) (Apply (NonEmpty a) (TyFun (NonEmpty a) (NonEmpty a) -> Type) (MaxSym0 (NonEmpty a)) t) t)

sMin :: Sing (NonEmpty a) t -> Sing (NonEmpty a) t -> Sing (NonEmpty a) (Apply (NonEmpty a) (NonEmpty a) (Apply (NonEmpty a) (TyFun (NonEmpty a) (NonEmpty a) -> Type) (MinSym0 (NonEmpty a)) t) t)

(SOrd a, SOrd b) => SOrd (Either a b)

Methods

sCompare :: Sing (Either a b) t -> Sing (Either a b) t -> Sing Ordering (Apply (Either a b) Ordering (Apply (Either a b) (TyFun (Either a b) Ordering -> Type) (CompareSym0 (Either a b)) t) t)

(%:<) :: Sing (Either a b) t -> Sing (Either a b) t -> Sing Bool (Apply (Either a b) Bool (Apply (Either a b) (TyFun (Either a b) Bool -> Type) ((:<$) (Either a b)) t) t)

(%:<=) :: Sing (Either a b) t -> Sing (Either a b) t -> Sing Bool (Apply (Either a b) Bool (Apply (Either a b) (TyFun (Either a b) Bool -> Type) ((:<=$) (Either a b)) t) t)

(%:>) :: Sing (Either a b) t -> Sing (Either a b) t -> Sing Bool (Apply (Either a b) Bool (Apply (Either a b) (TyFun (Either a b) Bool -> Type) ((:>$) (Either a b)) t) t)

(%:>=) :: Sing (Either a b) t -> Sing (Either a b) t -> Sing Bool (Apply (Either a b) Bool (Apply (Either a b) (TyFun (Either a b) Bool -> Type) ((:>=$) (Either a b)) t) t)

sMax :: Sing (Either a b) t -> Sing (Either a b) t -> Sing (Either a b) (Apply (Either a b) (Either a b) (Apply (Either a b) (TyFun (Either a b) (Either a b) -> Type) (MaxSym0 (Either a b)) t) t)

sMin :: Sing (Either a b) t -> Sing (Either a b) t -> Sing (Either a b) (Apply (Either a b) (Either a b) (Apply (Either a b) (TyFun (Either a b) (Either a b) -> Type) (MinSym0 (Either a b)) t) t)

(SOrd a, SOrd b) => SOrd (a, b)

Methods

sCompare :: Sing (a, b) t -> Sing (a, b) t -> Sing Ordering (Apply (a, b) Ordering (Apply (a, b) (TyFun (a, b) Ordering -> Type) (CompareSym0 (a, b)) t) t)

(%:<) :: Sing (a, b) t -> Sing (a, b) t -> Sing Bool (Apply (a, b) Bool (Apply (a, b) (TyFun (a, b) Bool -> Type) ((:<$) (a, b)) t) t)

(%:<=) :: Sing (a, b) t -> Sing (a, b) t -> Sing Bool (Apply (a, b) Bool (Apply (a, b) (TyFun (a, b) Bool -> Type) ((:<=$) (a, b)) t) t)

(%:>) :: Sing (a, b) t -> Sing (a, b) t -> Sing Bool (Apply (a, b) Bool (Apply (a, b) (TyFun (a, b) Bool -> Type) ((:>$) (a, b)) t) t)

(%:>=) :: Sing (a, b) t -> Sing (a, b) t -> Sing Bool (Apply (a, b) Bool (Apply (a, b) (TyFun (a, b) Bool -> Type) ((:>=$) (a, b)) t) t)

sMax :: Sing (a, b) t -> Sing (a, b) t -> Sing (a, b) (Apply (a, b) (a, b) (Apply (a, b) (TyFun (a, b) (a, b) -> Type) (MaxSym0 (a, b)) t) t)

sMin :: Sing (a, b) t -> Sing (a, b) t -> Sing (a, b) (Apply (a, b) (a, b) (Apply (a, b) (TyFun (a, b) (a, b) -> Type) (MinSym0 (a, b)) t) t)

(SOrd a, SOrd b, SOrd c) => SOrd (a, b, c)

Methods

sCompare :: Sing (a, b, c) t -> Sing (a, b, c) t -> Sing Ordering (Apply (a, b, c) Ordering (Apply (a, b, c) (TyFun (a, b, c) Ordering -> Type) (CompareSym0 (a, b, c)) t) t)

(%:<) :: Sing (a, b, c) t -> Sing (a, b, c) t -> Sing Bool (Apply (a, b, c) Bool (Apply (a, b, c) (TyFun (a, b, c) Bool -> Type) ((:<$) (a, b, c)) t) t)

(%:<=) :: Sing (a, b, c) t -> Sing (a, b, c) t -> Sing Bool (Apply (a, b, c) Bool (Apply (a, b, c) (TyFun (a, b, c) Bool -> Type) ((:<=$) (a, b, c)) t) t)

(%:>) :: Sing (a, b, c) t -> Sing (a, b, c) t -> Sing Bool (Apply (a, b, c) Bool (Apply (a, b, c) (TyFun (a, b, c) Bool -> Type) ((:>$) (a, b, c)) t) t)

(%:>=) :: Sing (a, b, c) t -> Sing (a, b, c) t -> Sing Bool (Apply (a, b, c) Bool (Apply (a, b, c) (TyFun (a, b, c) Bool -> Type) ((:>=$) (a, b, c)) t) t)

sMax :: Sing (a, b, c) t -> Sing (a, b, c) t -> Sing (a, b, c) (Apply (a, b, c) (a, b, c) (Apply (a, b, c) (TyFun (a, b, c) (a, b, c) -> Type) (MaxSym0 (a, b, c)) t) t)

sMin :: Sing (a, b, c) t -> Sing (a, b, c) t -> Sing (a, b, c) (Apply (a, b, c) (a, b, c) (Apply (a, b, c) (TyFun (a, b, c) (a, b, c) -> Type) (MinSym0 (a, b, c)) t) t)

(SOrd a, SOrd b, SOrd c, SOrd d) => SOrd (a, b, c, d)

Methods

sCompare :: Sing (a, b, c, d) t -> Sing (a, b, c, d) t -> Sing Ordering (Apply (a, b, c, d) Ordering (Apply (a, b, c, d) (TyFun (a, b, c, d) Ordering -> Type) (CompareSym0 (a, b, c, d)) t) t)

(%:<) :: Sing (a, b, c, d) t -> Sing (a, b, c, d) t -> Sing Bool (Apply (a, b, c, d) Bool (Apply (a, b, c, d) (TyFun (a, b, c, d) Bool -> Type) ((:<$) (a, b, c, d)) t) t)

(%:<=) :: Sing (a, b, c, d) t -> Sing (a, b, c, d) t -> Sing Bool (Apply (a, b, c, d) Bool (Apply (a, b, c, d) (TyFun (a, b, c, d) Bool -> Type) ((:<=$) (a, b, c, d)) t) t)

(%:>) :: Sing (a, b, c, d) t -> Sing (a, b, c, d) t -> Sing Bool (Apply (a, b, c, d) Bool (Apply (a, b, c, d) (TyFun (a, b, c, d) Bool -> Type) ((:>$) (a, b, c, d)) t) t)

(%:>=) :: Sing (a, b, c, d) t -> Sing (a, b, c, d) t -> Sing Bool (Apply (a, b, c, d) Bool (Apply (a, b, c, d) (TyFun (a, b, c, d) Bool -> Type) ((:>=$) (a, b, c, d)) t) t)

sMax :: Sing (a, b, c, d) t -> Sing (a, b, c, d) t -> Sing (a, b, c, d) (Apply (a, b, c, d) (a, b, c, d) (Apply (a, b, c, d) (TyFun (a, b, c, d) (a, b, c, d) -> Type) (MaxSym0 (a, b, c, d)) t) t)

sMin :: Sing (a, b, c, d) t -> Sing (a, b, c, d) t -> Sing (a, b, c, d) (Apply (a, b, c, d) (a, b, c, d) (Apply (a, b, c, d) (TyFun (a, b, c, d) (a, b, c, d) -> Type) (MinSym0 (a, b, c, d)) t) t)

(SOrd a, SOrd b, SOrd c, SOrd d, SOrd e) => SOrd (a, b, c, d, e)

Methods

sCompare :: Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) t -> Sing Ordering (Apply (a, b, c, d, e) Ordering (Apply (a, b, c, d, e) (TyFun (a, b, c, d, e) Ordering -> Type) (CompareSym0 (a, b, c, d, e)) t) t)

(%:<) :: Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) t -> Sing Bool (Apply (a, b, c, d, e) Bool (Apply (a, b, c, d, e) (TyFun (a, b, c, d, e) Bool -> Type) ((:<$) (a, b, c, d, e)) t) t)

(%:<=) :: Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) t -> Sing Bool (Apply (a, b, c, d, e) Bool (Apply (a, b, c, d, e) (TyFun (a, b, c, d, e) Bool -> Type) ((:<=$) (a, b, c, d, e)) t) t)

(%:>) :: Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) t -> Sing Bool (Apply (a, b, c, d, e) Bool (Apply (a, b, c, d, e) (TyFun (a, b, c, d, e) Bool -> Type) ((:>$) (a, b, c, d, e)) t) t)

(%:>=) :: Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) t -> Sing Bool (Apply (a, b, c, d, e) Bool (Apply (a, b, c, d, e) (TyFun (a, b, c, d, e) Bool -> Type) ((:>=$) (a, b, c, d, e)) t) t)

sMax :: Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) (Apply (a, b, c, d, e) (a, b, c, d, e) (Apply (a, b, c, d, e) (TyFun (a, b, c, d, e) (a, b, c, d, e) -> Type) (MaxSym0 (a, b, c, d, e)) t) t)

sMin :: Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) t -> Sing (a, b, c, d, e) (Apply (a, b, c, d, e) (a, b, c, d, e) (Apply (a, b, c, d, e) (TyFun (a, b, c, d, e) (a, b, c, d, e) -> Type) (MinSym0 (a, b, c, d, e)) t) t)

(SOrd a, SOrd b, SOrd c, SOrd d, SOrd e, SOrd f) => SOrd (a, b, c, d, e, f)

Methods

sCompare :: Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) t -> Sing Ordering (Apply (a, b, c, d, e, f) Ordering (Apply (a, b, c, d, e, f) (TyFun (a, b, c, d, e, f) Ordering -> Type) (CompareSym0 (a, b, c, d, e, f)) t) t)

(%:<) :: Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) t -> Sing Bool (Apply (a, b, c, d, e, f) Bool (Apply (a, b, c, d, e, f) (TyFun (a, b, c, d, e, f) Bool -> Type) ((:<$) (a, b, c, d, e, f)) t) t)

(%:<=) :: Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) t -> Sing Bool (Apply (a, b, c, d, e, f) Bool (Apply (a, b, c, d, e, f) (TyFun (a, b, c, d, e, f) Bool -> Type) ((:<=$) (a, b, c, d, e, f)) t) t)

(%:>) :: Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) t -> Sing Bool (Apply (a, b, c, d, e, f) Bool (Apply (a, b, c, d, e, f) (TyFun (a, b, c, d, e, f) Bool -> Type) ((:>$) (a, b, c, d, e, f)) t) t)

(%:>=) :: Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) t -> Sing Bool (Apply (a, b, c, d, e, f) Bool (Apply (a, b, c, d, e, f) (TyFun (a, b, c, d, e, f) Bool -> Type) ((:>=$) (a, b, c, d, e, f)) t) t)

sMax :: Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) (Apply (a, b, c, d, e, f) (a, b, c, d, e, f) (Apply (a, b, c, d, e, f) (TyFun (a, b, c, d, e, f) (a, b, c, d, e, f) -> Type) (MaxSym0 (a, b, c, d, e, f)) t) t)

sMin :: Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) t -> Sing (a, b, c, d, e, f) (Apply (a, b, c, d, e, f) (a, b, c, d, e, f) (Apply (a, b, c, d, e, f) (TyFun (a, b, c, d, e, f) (a, b, c, d, e, f) -> Type) (MinSym0 (a, b, c, d, e, f)) t) t)

(SOrd a, SOrd b, SOrd c, SOrd d, SOrd e, SOrd f, SOrd g) => SOrd (a, b, c, d, e, f, g)

Methods

sCompare :: Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) t -> Sing Ordering (Apply (a, b, c, d, e, f, g) Ordering (Apply (a, b, c, d, e, f, g) (TyFun (a, b, c, d, e, f, g) Ordering -> Type) (CompareSym0 (a, b, c, d, e, f, g)) t) t)

(%:<) :: Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) t -> Sing Bool (Apply (a, b, c, d, e, f, g) Bool (Apply (a, b, c, d, e, f, g) (TyFun (a, b, c, d, e, f, g) Bool -> Type) ((:<$) (a, b, c, d, e, f, g)) t) t)

(%:<=) :: Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) t -> Sing Bool (Apply (a, b, c, d, e, f, g) Bool (Apply (a, b, c, d, e, f, g) (TyFun (a, b, c, d, e, f, g) Bool -> Type) ((:<=$) (a, b, c, d, e, f, g)) t) t)

(%:>) :: Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) t -> Sing Bool (Apply (a, b, c, d, e, f, g) Bool (Apply (a, b, c, d, e, f, g) (TyFun (a, b, c, d, e, f, g) Bool -> Type) ((:>$) (a, b, c, d, e, f, g)) t) t)

(%:>=) :: Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) t -> Sing Bool (Apply (a, b, c, d, e, f, g) Bool (Apply (a, b, c, d, e, f, g) (TyFun (a, b, c, d, e, f, g) Bool -> Type) ((:>=$) (a, b, c, d, e, f, g)) t) t)

sMax :: Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) (Apply (a, b, c, d, e, f, g) (a, b, c, d, e, f, g) (Apply (a, b, c, d, e, f, g) (TyFun (a, b, c, d, e, f, g) (a, b, c, d, e, f, g) -> Type) (MaxSym0 (a, b, c, d, e, f, g)) t) t)

sMin :: Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) t -> Sing (a, b, c, d, e, f, g) (Apply (a, b, c, d, e, f, g) (a, b, c, d, e, f, g) (Apply (a, b, c, d, e, f, g) (TyFun (a, b, c, d, e, f, g) (a, b, c, d, e, f, g) -> Type) (MinSym0 (a, b, c, d, e, f, g)) t) t)

type family Comparing (a :: TyFun b a -> Type) (a :: b) (a :: b) :: Ordering where ...

Equations

Comparing p x y = Apply (Apply CompareSym0 (Apply p x)) (Apply p y)

sComparing :: forall (t :: TyFun b a -> Type) (t :: b) (t :: b). SOrd a => Sing t -> Sing t -> Sing t -> Sing (Apply (Apply (Apply ComparingSym0 t) t) t :: Ordering)

thenCmp returns its second argument if its first is EQ; otherwise, it returns its first argument.

thenCmp :: Ordering -> Ordering -> Ordering

type family ThenCmp (a :: Ordering) (a :: Ordering) :: Ordering where ...

Equations

ThenCmp EQ x = x

ThenCmp LT _z_6989586621679320849 = LTSym0

ThenCmp GT _z_6989586621679320852 = GTSym0

sThenCmp :: forall (t :: Ordering) (t :: Ordering). Sing t -> Sing t -> Sing (Apply (Apply ThenCmpSym0 t) t :: Ordering)

data family Sing (a :: k)

The singleton kind-indexed data family.

Instances

data Sing Bool

data Sing Bool where

• SFalse :: Sing Bool z
• STrue :: Sing Bool z

data Sing Ordering

data Sing Ordering where

• SLT :: Sing Ordering z
• SEQ :: Sing Ordering z
• SGT :: Sing Ordering z

data Sing *

data Sing * where

• STypeRep :: Sing * a

data Sing Nat

data Sing Nat where

• SNat :: Sing Nat n

data Sing Symbol

data Sing Symbol where

• SSym :: Sing Symbol n

data Sing ()

data Sing () where

• STuple0 :: Sing () z

data Sing [a]

data Sing [a] where

• SNil :: Sing [a] z
• SCons :: Sing [a] z

data Sing (Maybe a)

data Sing (Maybe a) where

• SNothing :: Sing (Maybe a) z
• SJust :: Sing (Maybe a) z

data Sing (NonEmpty a)

data Sing (NonEmpty a) where

• (:%|) :: Sing (NonEmpty a) z

data Sing (Either a b)

data Sing (Either a b) where

• SLeft :: Sing (Either a b) z
• SRight :: Sing (Either a b) z

data Sing (a, b)

data Sing (a, b) where

• STuple2 :: Sing (a, b) z

data Sing ((~>) k1 k2)

data Sing ((~>) k1 k2) = SLambda {

• applySing :: forall (t :: k1). Sing k1 t -> Sing k2 ((@@) k1 k2 f t)

}

data Sing (a, b, c)

data Sing (a, b, c) where

• STuple3 :: Sing (a, b, c) z

data Sing (a, b, c, d)

data Sing (a, b, c, d) where

• STuple4 :: Sing (a, b, c, d) z

data Sing (a, b, c, d, e)

data Sing (a, b, c, d, e) where

• STuple5 :: Sing (a, b, c, d, e) z

data Sing (a, b, c, d, e, f)

data Sing (a, b, c, d, e, f) where

• STuple6 :: Sing (a, b, c, d, e, f) z

data Sing (a, b, c, d, e, f, g)

data Sing (a, b, c, d, e, f, g) where

• STuple7 :: Sing (a, b, c, d, e, f, g) z

Defunctionalization symbols

data ThenCmpSym0 (l :: TyFun Ordering (TyFun Ordering Ordering -> Type))

Instances

SuppressUnusedWarnings (TyFun Ordering (TyFun Ordering Ordering -> Type) -> *) ThenCmpSym0

Methods

suppressUnusedWarnings :: Proxy ThenCmpSym0 t -> ()

type Apply Ordering (TyFun Ordering Ordering -> Type) ThenCmpSym0 l

type Apply Ordering (TyFun Ordering Ordering -> Type) ThenCmpSym0 l = ThenCmpSym1 l

data ThenCmpSym1 (l :: Ordering) (l :: TyFun Ordering Ordering)

Instances

SuppressUnusedWarnings (Ordering -> TyFun Ordering Ordering -> *) ThenCmpSym1

Methods

suppressUnusedWarnings :: Proxy ThenCmpSym1 t -> ()

type Apply Ordering Ordering (ThenCmpSym1 l1) l2

type Apply Ordering Ordering (ThenCmpSym1 l1) l2 = ThenCmp l1 l2

type ThenCmpSym2 (t :: Ordering) (t :: Ordering) = ThenCmp t t

type LTSym0 = LT

type EQSym0 = EQ

type GTSym0 = GT

data CompareSym0 (l :: TyFun a6989586621679312550 (TyFun a6989586621679312550 Ordering -> Type))

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 Ordering -> Type) -> *) (CompareSym0 a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy (CompareSym0 a6989586621679312550) t -> ()

type Apply a6989586621679312550 (TyFun a6989586621679312550 Ordering -> Type) (CompareSym0 a6989586621679312550) l

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

data CompareSym1 (l :: a6989586621679312550) (l :: TyFun a6989586621679312550 Ordering)

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Ordering -> *) (CompareSym1 a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy (CompareSym1 a6989586621679312550) t -> ()

type Apply a Ordering (CompareSym1 a l1) l2

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

type CompareSym2 (t :: a6989586621679312550) (t :: a6989586621679312550) = Compare t t

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

Instances

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

Methods

suppressUnusedWarnings :: Proxy ((:<$) a6989586621679312550) t -> ()

type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:<$) a6989586621679312550) l

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

data (l :: a6989586621679312550) :<$$ (l :: TyFun a6989586621679312550 Bool)

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Bool -> *) ((:<$$) a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy ((:<$$) a6989586621679312550) t -> ()

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

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

type (:<$$$) (t :: a6989586621679312550) (t :: a6989586621679312550) = (:<) t t

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

Instances

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

Methods

suppressUnusedWarnings :: Proxy ((:<=$) a6989586621679312550) t -> ()

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

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

data (l :: a6989586621679312550) :<=$$ (l :: TyFun a6989586621679312550 Bool)

Instances

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

Methods

suppressUnusedWarnings :: Proxy ((:<=$$) a6989586621679312550) t -> ()

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

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

type (:<=$$$) (t :: a6989586621679312550) (t :: a6989586621679312550) = (:<=) t t

data (:>$) (l :: TyFun a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type))

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) -> *) ((:>$) a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy ((:>$) a6989586621679312550) t -> ()

type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:>$) a6989586621679312550) l

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

data (l :: a6989586621679312550) :>$$ (l :: TyFun a6989586621679312550 Bool)

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Bool -> *) ((:>$$) a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy ((:>$$) a6989586621679312550) t -> ()

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

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

type (:>$$$) (t :: a6989586621679312550) (t :: a6989586621679312550) = (:>) t t

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

Instances

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

Methods

suppressUnusedWarnings :: Proxy ((:>=$) a6989586621679312550) t -> ()

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

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

data (l :: a6989586621679312550) :>=$$ (l :: TyFun a6989586621679312550 Bool)

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Bool -> *) ((:>=$$) a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy ((:>=$$) a6989586621679312550) t -> ()

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

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

type (:>=$$$) (t :: a6989586621679312550) (t :: a6989586621679312550) = (:>=) t t

data MaxSym0 (l :: TyFun a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type))

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) -> *) (MaxSym0 a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy (MaxSym0 a6989586621679312550) t -> ()

type Apply a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) (MaxSym0 a6989586621679312550) l

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

data MaxSym1 (l :: a6989586621679312550) (l :: TyFun a6989586621679312550 a6989586621679312550)

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 a6989586621679312550 -> *) (MaxSym1 a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy (MaxSym1 a6989586621679312550) t -> ()

type Apply a a (MaxSym1 a l1) l2

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

type MaxSym2 (t :: a6989586621679312550) (t :: a6989586621679312550) = Max t t

data MinSym0 (l :: TyFun a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type))

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) -> *) (MinSym0 a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy (MinSym0 a6989586621679312550) t -> ()

type Apply a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) (MinSym0 a6989586621679312550) l

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

data MinSym1 (l :: a6989586621679312550) (l :: TyFun a6989586621679312550 a6989586621679312550)

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 a6989586621679312550 -> *) (MinSym1 a6989586621679312550)

Methods

suppressUnusedWarnings :: Proxy (MinSym1 a6989586621679312550) t -> ()

type Apply a a (MinSym1 a l1) l2

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

type MinSym2 (t :: a6989586621679312550) (t :: a6989586621679312550) = Min t t

data ComparingSym0 (l :: TyFun (TyFun b6989586621679312540 a6989586621679312539 -> Type) (TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) -> Type))

Instances

SuppressUnusedWarnings (TyFun (TyFun b6989586621679312540 a6989586621679312539 -> Type) (TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) -> Type) -> *) (ComparingSym0 a6989586621679312539 b6989586621679312540)

Methods

suppressUnusedWarnings :: Proxy (ComparingSym0 a6989586621679312539 b6989586621679312540) t -> ()

type Apply (TyFun b6989586621679312540 a6989586621679312539 -> Type) (TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) -> Type) (ComparingSym0 a6989586621679312539 b6989586621679312540) l

type Apply (TyFun b6989586621679312540 a6989586621679312539 -> Type) (TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) -> Type) (ComparingSym0 a6989586621679312539 b6989586621679312540) l = ComparingSym1 a6989586621679312539 b6989586621679312540 l

data ComparingSym1 (l :: TyFun b6989586621679312540 a6989586621679312539 -> Type) (l :: TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type))

Instances

SuppressUnusedWarnings ((TyFun b6989586621679312540 a6989586621679312539 -> Type) -> TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) -> *) (ComparingSym1 a6989586621679312539 b6989586621679312540)

Methods

suppressUnusedWarnings :: Proxy (ComparingSym1 a6989586621679312539 b6989586621679312540) t -> ()

type Apply b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) (ComparingSym1 a6989586621679312539 b6989586621679312540 l1) l2

type Apply b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) (ComparingSym1 a6989586621679312539 b6989586621679312540 l1) l2 = ComparingSym2 a6989586621679312539 b6989586621679312540 l1 l2

data ComparingSym2 (l :: TyFun b6989586621679312540 a6989586621679312539 -> Type) (l :: b6989586621679312540) (l :: TyFun b6989586621679312540 Ordering)

Instances

SuppressUnusedWarnings ((TyFun b6989586621679312540 a6989586621679312539 -> Type) -> b6989586621679312540 -> TyFun b6989586621679312540 Ordering -> *) (ComparingSym2 a6989586621679312539 b6989586621679312540)

Methods

suppressUnusedWarnings :: Proxy (ComparingSym2 a6989586621679312539 b6989586621679312540) t -> ()

type Apply b Ordering (ComparingSym2 a b l1 l2) l3

type Apply b Ordering (ComparingSym2 a b l1 l2) l3 = Comparing a b l1 l2 l3

type ComparingSym3 (t :: TyFun b6989586621679312540 a6989586621679312539 -> Type) (t :: b6989586621679312540) (t :: b6989586621679312540) = Comparing t t t