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

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_1627706336Sym0 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_1627706369Sym0 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_1627706402Sym0 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_1627706435Sym0 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_1627706468Sym0 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_1627706501Sym0 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_1627706534Sym0 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_1627713217 = LTSym0
ThenCmp GT _z_1627713220 = 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 a1627704908 (TyFun a1627704908 Ordering -> Type)) #

Instances

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

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

Instances

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

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

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

Instances

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

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

Instances

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

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

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

Instances

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

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

Instances

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

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

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

Instances

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

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

Instances

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

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

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

Instances

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

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

Instances

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

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

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

Instances

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

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

Instances

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

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

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

Instances

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

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

Instances

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

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

data ComparingSym0 (l :: TyFun (TyFun b1627704898 a1627704897 -> Type) (TyFun b1627704898 (TyFun b1627704898 Ordering -> Type) -> Type)) #

Instances

SuppressUnusedWarnings (TyFun (TyFun b1627704898 a1627704897 -> Type) (TyFun b1627704898 (TyFun b1627704898 Ordering -> Type) -> Type) -> *) (ComparingSym0 a1627704897 b1627704898) #
Methods suppressUnusedWarnings :: Proxy (ComparingSym0 a1627704897 b1627704898) t -> () #
type Apply (TyFun b1627704898 a1627704897 -> Type) (TyFun b1627704898 (TyFun b1627704898 Ordering -> Type) -> Type) (ComparingSym0 a1627704897 b1627704898) l #
type Apply (TyFun b1627704898 a1627704897 -> Type) (TyFun b1627704898 (TyFun b1627704898 Ordering -> Type) -> Type) (ComparingSym0 a1627704897 b1627704898) l = ComparingSym1 a1627704897 b1627704898 l

data ComparingSym1 (l :: TyFun b1627704898 a1627704897 -> Type) (l :: TyFun b1627704898 (TyFun b1627704898 Ordering -> Type)) #

Instances

SuppressUnusedWarnings ((TyFun b1627704898 a1627704897 -> Type) -> TyFun b1627704898 (TyFun b1627704898 Ordering -> Type) -> *) (ComparingSym1 a1627704897 b1627704898) #
Methods suppressUnusedWarnings :: Proxy (ComparingSym1 a1627704897 b1627704898) t -> () #
type Apply b1627704898 (TyFun b1627704898 Ordering -> Type) (ComparingSym1 a1627704897 b1627704898 l1) l2 #
type Apply b1627704898 (TyFun b1627704898 Ordering -> Type) (ComparingSym1 a1627704897 b1627704898 l1) l2 = ComparingSym2 a1627704897 b1627704898 l1 l2

data ComparingSym2 (l :: TyFun b1627704898 a1627704897 -> Type) (l :: b1627704898) (l :: TyFun b1627704898 Ordering) #

Instances

SuppressUnusedWarnings ((TyFun b1627704898 a1627704897 -> Type) -> b1627704898 -> TyFun b1627704898 Ordering -> *) (ComparingSym2 a1627704897 b1627704898) #
Methods suppressUnusedWarnings :: Proxy (ComparingSym2 a1627704897 b1627704898) 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 b1627704898 a1627704897 -> Type) (t :: b1627704898) (t :: b1627704898) = Comparing t t t #