Copyright	(C) 2013 Richard Eisenberg
License	BSD-style (see LICENSE)
Maintainer	Richard Eisenberg (rae@cs.brynmawr.edu)
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Data.Singletons.Prelude.Ord

Contents

Defunctionalization symbols

Description

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

Synopsis

Documentation

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

Associated Types

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

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

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

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

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

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

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

Instances

POrd Bool Source #
Associated Types type Compare Bool (arg :: Bool) (arg :: Bool) :: Ordering Source # type (Bool :< (arg :: Bool)) (arg :: Bool) :: Bool Source # type (Bool :<= (arg :: Bool)) (arg :: Bool) :: Bool Source # type (Bool :> (arg :: Bool)) (arg :: Bool) :: Bool Source # type (Bool :>= (arg :: Bool)) (arg :: Bool) :: Bool Source # type Max Bool (arg :: Bool) (arg :: Bool) :: a Source # type Min Bool (arg :: Bool) (arg :: Bool) :: a Source #
POrd Ordering Source #
Associated Types type Compare Ordering (arg :: Ordering) (arg :: Ordering) :: Ordering Source # type (Ordering :< (arg :: Ordering)) (arg :: Ordering) :: Bool Source # type (Ordering :<= (arg :: Ordering)) (arg :: Ordering) :: Bool Source # type (Ordering :> (arg :: Ordering)) (arg :: Ordering) :: Bool Source # type (Ordering :>= (arg :: Ordering)) (arg :: Ordering) :: Bool Source # type Max Ordering (arg :: Ordering) (arg :: Ordering) :: a Source # type Min Ordering (arg :: Ordering) (arg :: Ordering) :: a Source #
POrd () Source #
Associated Types type Compare () (arg :: ()) (arg :: ()) :: Ordering Source # type (() :< (arg :: ())) (arg :: ()) :: Bool Source # type (() :<= (arg :: ())) (arg :: ()) :: Bool Source # type (() :> (arg :: ())) (arg :: ()) :: Bool Source # type (() :>= (arg :: ())) (arg :: ()) :: Bool Source # type Max () (arg :: ()) (arg :: ()) :: a Source # type Min () (arg :: ()) (arg :: ()) :: a Source #
POrd [a] Source #
Associated Types type Compare [a] (arg :: [a]) (arg :: [a]) :: Ordering Source # type ([a] :< (arg :: [a])) (arg :: [a]) :: Bool Source # type ([a] :<= (arg :: [a])) (arg :: [a]) :: Bool Source # type ([a] :> (arg :: [a])) (arg :: [a]) :: Bool Source # type ([a] :>= (arg :: [a])) (arg :: [a]) :: Bool Source # type Max [a] (arg :: [a]) (arg :: [a]) :: a Source # type Min [a] (arg :: [a]) (arg :: [a]) :: a Source #
POrd (Maybe a) Source #
Associated Types type Compare (Maybe a) (arg :: Maybe a) (arg :: Maybe a) :: Ordering Source # type ((Maybe a) :< (arg :: Maybe a)) (arg :: Maybe a) :: Bool Source # type ((Maybe a) :<= (arg :: Maybe a)) (arg :: Maybe a) :: Bool Source # type ((Maybe a) :> (arg :: Maybe a)) (arg :: Maybe a) :: Bool Source # type ((Maybe a) :>= (arg :: Maybe a)) (arg :: Maybe a) :: Bool Source # type Max (Maybe a) (arg :: Maybe a) (arg :: Maybe a) :: a Source # type Min (Maybe a) (arg :: Maybe a) (arg :: Maybe a) :: a Source #
POrd (NonEmpty a) Source #
Associated Types type Compare (NonEmpty a) (arg :: NonEmpty a) (arg :: NonEmpty a) :: Ordering Source # type ((NonEmpty a) :< (arg :: NonEmpty a)) (arg :: NonEmpty a) :: Bool Source # type ((NonEmpty a) :<= (arg :: NonEmpty a)) (arg :: NonEmpty a) :: Bool Source # type ((NonEmpty a) :> (arg :: NonEmpty a)) (arg :: NonEmpty a) :: Bool Source # type ((NonEmpty a) :>= (arg :: NonEmpty a)) (arg :: NonEmpty a) :: Bool Source # type Max (NonEmpty a) (arg :: NonEmpty a) (arg :: NonEmpty a) :: a Source # type Min (NonEmpty a) (arg :: NonEmpty a) (arg :: NonEmpty a) :: a Source #
POrd (Either a b) Source #
Associated Types type Compare (Either a b) (arg :: Either a b) (arg :: Either a b) :: Ordering Source # type ((Either a b) :< (arg :: Either a b)) (arg :: Either a b) :: Bool Source # type ((Either a b) :<= (arg :: Either a b)) (arg :: Either a b) :: Bool Source # type ((Either a b) :> (arg :: Either a b)) (arg :: Either a b) :: Bool Source # type ((Either a b) :>= (arg :: Either a b)) (arg :: Either a b) :: Bool Source # type Max (Either a b) (arg :: Either a b) (arg :: Either a b) :: a Source # type Min (Either a b) (arg :: Either a b) (arg :: Either a b) :: a Source #
POrd (a, b) Source #
Associated Types type Compare (a, b) (arg :: (a, b)) (arg :: (a, b)) :: Ordering Source # type ((a, b) :< (arg :: (a, b))) (arg :: (a, b)) :: Bool Source # type ((a, b) :<= (arg :: (a, b))) (arg :: (a, b)) :: Bool Source # type ((a, b) :> (arg :: (a, b))) (arg :: (a, b)) :: Bool Source # type ((a, b) :>= (arg :: (a, b))) (arg :: (a, b)) :: Bool Source # type Max (a, b) (arg :: (a, b)) (arg :: (a, b)) :: a Source # type Min (a, b) (arg :: (a, b)) (arg :: (a, b)) :: a Source #
POrd (a, b, c) Source #
Associated Types type Compare (a, b, c) (arg :: (a, b, c)) (arg :: (a, b, c)) :: Ordering Source # type ((a, b, c) :< (arg :: (a, b, c))) (arg :: (a, b, c)) :: Bool Source # type ((a, b, c) :<= (arg :: (a, b, c))) (arg :: (a, b, c)) :: Bool Source # type ((a, b, c) :> (arg :: (a, b, c))) (arg :: (a, b, c)) :: Bool Source # type ((a, b, c) :>= (arg :: (a, b, c))) (arg :: (a, b, c)) :: Bool Source # type Max (a, b, c) (arg :: (a, b, c)) (arg :: (a, b, c)) :: a Source # type Min (a, b, c) (arg :: (a, b, c)) (arg :: (a, b, c)) :: a Source #
POrd (a, b, c, d) Source #
Associated Types type Compare (a, b, c, d) (arg :: (a, b, c, d)) (arg :: (a, b, c, d)) :: Ordering Source # type ((a, b, c, d) :< (arg :: (a, b, c, d))) (arg :: (a, b, c, d)) :: Bool Source # type ((a, b, c, d) :<= (arg :: (a, b, c, d))) (arg :: (a, b, c, d)) :: Bool Source # type ((a, b, c, d) :> (arg :: (a, b, c, d))) (arg :: (a, b, c, d)) :: Bool Source # type ((a, b, c, d) :>= (arg :: (a, b, c, d))) (arg :: (a, b, c, d)) :: Bool Source # type Max (a, b, c, d) (arg :: (a, b, c, d)) (arg :: (a, b, c, d)) :: a Source # type Min (a, b, c, d) (arg :: (a, b, c, d)) (arg :: (a, b, c, d)) :: a Source #
POrd (a, b, c, d, e) Source #
Associated Types type Compare (a, b, c, d, e) (arg :: (a, b, c, d, e)) (arg :: (a, b, c, d, e)) :: Ordering Source # type ((a, b, c, d, e) :< (arg :: (a, b, c, d, e))) (arg :: (a, b, c, d, e)) :: Bool Source # type ((a, b, c, d, e) :<= (arg :: (a, b, c, d, e))) (arg :: (a, b, c, d, e)) :: Bool Source # type ((a, b, c, d, e) :> (arg :: (a, b, c, d, e))) (arg :: (a, b, c, d, e)) :: Bool Source # type ((a, b, c, d, e) :>= (arg :: (a, b, c, d, e))) (arg :: (a, b, c, d, e)) :: Bool Source # type Max (a, b, c, d, e) (arg :: (a, b, c, d, e)) (arg :: (a, b, c, d, e)) :: a Source # type Min (a, b, c, d, e) (arg :: (a, b, c, d, e)) (arg :: (a, b, c, d, e)) :: a Source #
POrd (a, b, c, d, e, f) Source #
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 Source # type ((a, b, c, d, e, f) :< (arg :: (a, b, c, d, e, f))) (arg :: (a, b, c, d, e, f)) :: Bool Source # type ((a, b, c, d, e, f) :<= (arg :: (a, b, c, d, e, f))) (arg :: (a, b, c, d, e, f)) :: Bool Source # type ((a, b, c, d, e, f) :> (arg :: (a, b, c, d, e, f))) (arg :: (a, b, c, d, e, f)) :: Bool Source # type ((a, b, c, d, e, f) :>= (arg :: (a, b, c, d, e, f))) (arg :: (a, b, c, d, e, f)) :: Bool Source # type Max (a, b, c, d, e, f) (arg :: (a, b, c, d, e, f)) (arg :: (a, b, c, d, e, f)) :: a Source # type Min (a, b, c, d, e, f) (arg :: (a, b, c, d, e, f)) (arg :: (a, b, c, d, e, f)) :: a Source #
POrd (a, b, c, d, e, f, g) Source #
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 Source # 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 Source # 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 Source # 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 Source # 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 Source # 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 Source # 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 Source #

class SEq a => SOrd a where Source #

Methods

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

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

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

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

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

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

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

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) Source #

(%:<) :: 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 Source #

(%:<=) :: 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 Source #

(%:>) :: 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 Source #

(%:>=) :: 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 Source #

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) Source #

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) Source #

Instances

SOrd Bool Source #
Methods sCompare :: Sing Bool t -> Sing Bool t -> Sing Ordering (Apply Bool Ordering (Apply Bool (TyFun Bool Ordering -> Type) (CompareSym0 Bool) t) t) Source # (%:<) :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) ((:<$) Bool) t) t) Source # (%:<=) :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) ((:<=$) Bool) t) t) Source # (%:>) :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) ((:>$) Bool) t) t) Source # (%:>=) :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) ((:>=$) Bool) t) t) Source # sMax :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) (MaxSym0 Bool) t) t) Source # sMin :: Sing Bool t -> Sing Bool t -> Sing Bool (Apply Bool Bool (Apply Bool (TyFun Bool Bool -> Type) (MinSym0 Bool) t) t) Source #
SOrd Ordering Source #
Methods sCompare :: Sing Ordering t -> Sing Ordering t -> Sing Ordering (Apply Ordering Ordering (Apply Ordering (TyFun Ordering Ordering -> Type) (CompareSym0 Ordering) t) t) Source # (%:<) :: Sing Ordering t -> Sing Ordering t -> Sing Bool (Apply Ordering Bool (Apply Ordering (TyFun Ordering Bool -> Type) ((:<$) Ordering) t) t) Source # (%:<=) :: Sing Ordering t -> Sing Ordering t -> Sing Bool (Apply Ordering Bool (Apply Ordering (TyFun Ordering Bool -> Type) ((:<=$) Ordering) t) t) Source # (%:>) :: Sing Ordering t -> Sing Ordering t -> Sing Bool (Apply Ordering Bool (Apply Ordering (TyFun Ordering Bool -> Type) ((:>$) Ordering) t) t) Source # (%:>=) :: Sing Ordering t -> Sing Ordering t -> Sing Bool (Apply Ordering Bool (Apply Ordering (TyFun Ordering Bool -> Type) ((:>=$) Ordering) t) t) Source # sMax :: Sing Ordering t -> Sing Ordering t -> Sing Ordering (Apply Ordering Ordering (Apply Ordering (TyFun Ordering Ordering -> Type) (MaxSym0 Ordering) t) t) Source # sMin :: Sing Ordering t -> Sing Ordering t -> Sing Ordering (Apply Ordering Ordering (Apply Ordering (TyFun Ordering Ordering -> Type) (MinSym0 Ordering) t) t) Source #
SOrd () Source #
Methods sCompare :: Sing () t -> Sing () t -> Sing Ordering (Apply () Ordering (Apply () (TyFun () Ordering -> Type) (CompareSym0 ()) t) t) Source # (%:<) :: Sing () t -> Sing () t -> Sing Bool (Apply () Bool (Apply () (TyFun () Bool -> Type) ((:<$) ()) t) t) Source # (%:<=) :: Sing () t -> Sing () t -> Sing Bool (Apply () Bool (Apply () (TyFun () Bool -> Type) ((:<=$) ()) t) t) Source # (%:>) :: Sing () t -> Sing () t -> Sing Bool (Apply () Bool (Apply () (TyFun () Bool -> Type) ((:>$) ()) t) t) Source # (%:>=) :: Sing () t -> Sing () t -> Sing Bool (Apply () Bool (Apply () (TyFun () Bool -> Type) ((:>=$) ()) t) t) Source # sMax :: Sing () t -> Sing () t -> Sing () (Apply () () (Apply () (TyFun () () -> Type) (MaxSym0 ()) t) t) Source # sMin :: Sing () t -> Sing () t -> Sing () (Apply () () (Apply () (TyFun () () -> Type) (MinSym0 ()) t) t) Source #
(SOrd a, SOrd [a]) => SOrd [a] Source #
Methods sCompare :: Sing [a] t -> Sing [a] t -> Sing Ordering (Apply [a] Ordering (Apply [a] (TyFun [a] Ordering -> Type) (CompareSym0 [a]) t) t) Source # (%:<) :: Sing [a] t -> Sing [a] t -> Sing Bool (Apply [a] Bool (Apply [a] (TyFun [a] Bool -> Type) ((:<$) [a]) t) t) Source # (%:<=) :: Sing [a] t -> Sing [a] t -> Sing Bool (Apply [a] Bool (Apply [a] (TyFun [a] Bool -> Type) ((:<=$) [a]) t) t) Source # (%:>) :: Sing [a] t -> Sing [a] t -> Sing Bool (Apply [a] Bool (Apply [a] (TyFun [a] Bool -> Type) ((:>$) [a]) t) t) Source # (%:>=) :: Sing [a] t -> Sing [a] t -> Sing Bool (Apply [a] Bool (Apply [a] (TyFun [a] Bool -> Type) ((:>=$) [a]) t) t) Source # sMax :: Sing [a] t -> Sing [a] t -> Sing [a] (Apply [a] [a] (Apply [a] (TyFun [a] [a] -> Type) (MaxSym0 [a]) t) t) Source # sMin :: Sing [a] t -> Sing [a] t -> Sing [a] (Apply [a] [a] (Apply [a] (TyFun [a] [a] -> Type) (MinSym0 [a]) t) t) Source #
SOrd a => SOrd (Maybe a) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #
(SOrd a, SOrd [a]) => SOrd (NonEmpty a) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #
(SOrd a, SOrd b) => SOrd (Either a b) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #
(SOrd a, SOrd b) => SOrd (a, b) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #
(SOrd a, SOrd b, SOrd c) => SOrd (a, b, c) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #
(SOrd a, SOrd b, SOrd c, SOrd d) => SOrd (a, b, c, d) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #
(SOrd a, SOrd b, SOrd c, SOrd d, SOrd e) => SOrd (a, b, c, d, e) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #
(SOrd a, SOrd b, SOrd c, SOrd d, SOrd e, SOrd f) => SOrd (a, b, c, d, e, f) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #
(SOrd a, SOrd b, SOrd c, SOrd d, SOrd e, SOrd f, SOrd g) => SOrd (a, b, c, d, e, f, g) Source #
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) Source # (%:<) :: 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) Source # (%:<=) :: 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) Source # (%:>) :: 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) Source # (%:>=) :: 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) Source # 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) Source # 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) Source #

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

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) Source #

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

thenCmp :: Ordering -> Ordering -> Ordering Source #

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

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) Source #

data family Sing (a :: k) Source #

The singleton kind-indexed data family.

Instances

data Sing Bool Source #
data Sing Bool where SFalse :: Sing Bool z STrue :: Sing Bool z
data Sing Ordering Source #
data Sing Ordering where SLT :: Sing Ordering z SEQ :: Sing Ordering z SGT :: Sing Ordering z
data Sing * Source #
data Sing * where STypeRep :: Sing * a
data Sing Nat Source #
data Sing Nat where SNat :: Sing Nat n
data Sing Symbol Source #
data Sing Symbol where SSym :: Sing Symbol n
data Sing () Source #
data Sing () where STuple0 :: Sing () z
data Sing [a] Source #
data Sing [a] where SNil :: Sing [a] z SCons :: Sing [a] z
data Sing (Maybe a) Source #
data Sing (Maybe a) where SNothing :: Sing (Maybe a) z SJust :: Sing (Maybe a) z
data Sing (NonEmpty a) Source #
data Sing (NonEmpty a) where (:%\|) :: Sing (NonEmpty a) z
data Sing (Either a b) Source #
data Sing (Either a b) where SLeft :: Sing (Either a b) z SRight :: Sing (Either a b) z
data Sing (a, b) Source #
data Sing (a, b) where STuple2 :: Sing (a, b) z
data Sing ((~>) k1 k2) Source #
data Sing ((~>) k1 k2) = SLambda { applySing :: forall (t :: k1). Sing k1 t -> Sing k2 ((@@) k1 k2 f t) }
data Sing (a, b, c) Source #
data Sing (a, b, c) where STuple3 :: Sing (a, b, c) z
data Sing (a, b, c, d) Source #
data Sing (a, b, c, d) where STuple4 :: Sing (a, b, c, d) z
data Sing (a, b, c, d, e) Source #
data Sing (a, b, c, d, e) where STuple5 :: Sing (a, b, c, d, e) z
data Sing (a, b, c, d, e, f) Source #
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) Source #
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)) Source #

Instances

SuppressUnusedWarnings (TyFun Ordering (TyFun Ordering Ordering -> Type) -> *) ThenCmpSym0 Source #
Methods suppressUnusedWarnings :: Proxy ThenCmpSym0 t -> () Source #
type Apply Ordering (TyFun Ordering Ordering -> Type) ThenCmpSym0 l Source #
type Apply Ordering (TyFun Ordering Ordering -> Type) ThenCmpSym0 l = ThenCmpSym1 l

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

Instances

SuppressUnusedWarnings (Ordering -> TyFun Ordering Ordering -> *) ThenCmpSym1 Source #
Methods suppressUnusedWarnings :: Proxy ThenCmpSym1 t -> () Source #
type Apply Ordering Ordering (ThenCmpSym1 l1) l2 Source #
type Apply Ordering Ordering (ThenCmpSym1 l1) l2 = ThenCmp l1 l2

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

type LTSym0 = LT Source #

type EQSym0 = EQ Source #

type GTSym0 = GT Source #

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

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 Ordering -> Type) -> *) (CompareSym0 a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy (CompareSym0 a6989586621679312550) t -> () Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Ordering -> Type) (CompareSym0 a6989586621679312550) l Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Ordering -> Type) (CompareSym0 a6989586621679312550) l = CompareSym1 a6989586621679312550 l

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

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Ordering -> *) (CompareSym1 a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy (CompareSym1 a6989586621679312550) t -> () Source #
type Apply a Ordering (CompareSym1 a l1) l2 Source #
type Apply a Ordering (CompareSym1 a l1) l2 = Compare a l1 l2

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

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

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) -> *) ((:<$) a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy ((:<$) a6989586621679312550) t -> () Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:<$) a6989586621679312550) l Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:<$) a6989586621679312550) l = (:<$$) a6989586621679312550 l

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

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Bool -> *) ((:<$$) a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy ((:<$$) a6989586621679312550) t -> () Source #
type Apply a Bool ((:<$$) a l1) l2 Source #
type Apply a Bool ((:<$$) a l1) l2 = (:<) a l1 l2

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

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

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) -> *) ((:<=$) a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy ((:<=$) a6989586621679312550) t -> () Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:<=$) a6989586621679312550) l Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:<=$) a6989586621679312550) l = (:<=$$) a6989586621679312550 l

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

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Bool -> *) ((:<=$$) a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy ((:<=$$) a6989586621679312550) t -> () Source #
type Apply a Bool ((:<=$$) a l1) l2 Source #
type Apply a Bool ((:<=$$) a l1) l2 = (:<=) a l1 l2

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

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

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) -> *) ((:>$) a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy ((:>$) a6989586621679312550) t -> () Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:>$) a6989586621679312550) l Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:>$) a6989586621679312550) l = (:>$$) a6989586621679312550 l

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

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Bool -> *) ((:>$$) a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy ((:>$$) a6989586621679312550) t -> () Source #
type Apply a Bool ((:>$$) a l1) l2 Source #
type Apply a Bool ((:>$$) a l1) l2 = (:>) a l1 l2

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

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

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) -> *) ((:>=$) a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy ((:>=$) a6989586621679312550) t -> () Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:>=$) a6989586621679312550) l Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 Bool -> Type) ((:>=$) a6989586621679312550) l = (:>=$$) a6989586621679312550 l

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

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 Bool -> *) ((:>=$$) a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy ((:>=$$) a6989586621679312550) t -> () Source #
type Apply a Bool ((:>=$$) a l1) l2 Source #
type Apply a Bool ((:>=$$) a l1) l2 = (:>=) a l1 l2

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

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

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) -> *) (MaxSym0 a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy (MaxSym0 a6989586621679312550) t -> () Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) (MaxSym0 a6989586621679312550) l Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) (MaxSym0 a6989586621679312550) l = MaxSym1 a6989586621679312550 l

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

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 a6989586621679312550 -> *) (MaxSym1 a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy (MaxSym1 a6989586621679312550) t -> () Source #
type Apply a a (MaxSym1 a l1) l2 Source #
type Apply a a (MaxSym1 a l1) l2 = Max a l1 l2

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

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

Instances

SuppressUnusedWarnings (TyFun a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) -> *) (MinSym0 a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy (MinSym0 a6989586621679312550) t -> () Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) (MinSym0 a6989586621679312550) l Source #
type Apply a6989586621679312550 (TyFun a6989586621679312550 a6989586621679312550 -> Type) (MinSym0 a6989586621679312550) l = MinSym1 a6989586621679312550 l

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

Instances

SuppressUnusedWarnings (a6989586621679312550 -> TyFun a6989586621679312550 a6989586621679312550 -> *) (MinSym1 a6989586621679312550) Source #
Methods suppressUnusedWarnings :: Proxy (MinSym1 a6989586621679312550) t -> () Source #
type Apply a a (MinSym1 a l1) l2 Source #
type Apply a a (MinSym1 a l1) l2 = Min a l1 l2

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

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

Instances

SuppressUnusedWarnings (TyFun (TyFun b6989586621679312540 a6989586621679312539 -> Type) (TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) -> Type) -> *) (ComparingSym0 a6989586621679312539 b6989586621679312540) Source #
Methods suppressUnusedWarnings :: Proxy (ComparingSym0 a6989586621679312539 b6989586621679312540) t -> () Source #
type Apply (TyFun b6989586621679312540 a6989586621679312539 -> Type) (TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) -> Type) (ComparingSym0 a6989586621679312539 b6989586621679312540) l Source #
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)) Source #

Instances

SuppressUnusedWarnings ((TyFun b6989586621679312540 a6989586621679312539 -> Type) -> TyFun b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) -> *) (ComparingSym1 a6989586621679312539 b6989586621679312540) Source #
Methods suppressUnusedWarnings :: Proxy (ComparingSym1 a6989586621679312539 b6989586621679312540) t -> () Source #
type Apply b6989586621679312540 (TyFun b6989586621679312540 Ordering -> Type) (ComparingSym1 a6989586621679312539 b6989586621679312540 l1) l2 Source #
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) Source #

Instances

SuppressUnusedWarnings ((TyFun b6989586621679312540 a6989586621679312539 -> Type) -> b6989586621679312540 -> TyFun b6989586621679312540 Ordering -> *) (ComparingSym2 a6989586621679312539 b6989586621679312540) Source #
Methods suppressUnusedWarnings :: Proxy (ComparingSym2 a6989586621679312539 b6989586621679312540) t -> () Source #
type Apply b Ordering (ComparingSym2 a b l1 l2) l3 Source #
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 Source #