Data.Singletons.Prelude.Either

Defines functions and datatypes relating to the singleton for Either, including a singletons version of all the definitions in Data.Either.

Because many of these definitions are produced by Template Haskell, it is not possible to create proper Haddock documentation. Please look up the corresponding operation in Data.Either. Also, please excuse the apparent repeated variable names. This is due to an interaction between Template Haskell and Haddock.

The Either singleton

data family Sing a

The singleton kind-indexed data family.

Instances

TestCoercion * (Sing *)

SDecide k (KProxy k) => TestEquality k (Sing k)

data Sing Bool where

• SFalse :: (~) Bool z False => Sing Bool z
• STrue :: (~) Bool z True => Sing Bool z

data Sing Ordering where

• SLT :: (~) Ordering z LT => Sing Ordering z
• SEQ :: (~) Ordering z EQ => Sing Ordering z
• SGT :: (~) Ordering z GT => Sing Ordering z

data Sing * where

• STypeRep :: Typeable * a => Sing * a

data Sing Nat where

• SNat :: KnownNat n => Sing Nat n

data Sing Symbol where

• SSym :: KnownSymbol n => Sing Symbol n

data Sing () where

• STuple0 :: (~) () z () => Sing () z

data Sing [a0] where

• SNil :: (~) [a] z ([] a) => Sing [a] z
• SCons :: (~) [a] z ((:) a n n) => Sing a n -> Sing [a] n -> Sing [a] z

data Sing (Maybe a0) where

• SNothing :: (~) (Maybe a) z (Nothing a) => Sing (Maybe a) z
• SJust :: (~) (Maybe a) z (Just a n) => Sing a n -> Sing (Maybe a) z

data Sing (TyFun k1 k2 -> *) = SLambda {

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

}

data Sing (Either a0 b0) where

• SLeft :: (~) (Either a b) z (Left a b n) => Sing a n -> Sing (Either a b) z
• SRight :: (~) (Either a b) z (Right a b n) => Sing b n -> Sing (Either a b) z

data Sing ((,) a0 b0) where

• STuple2 :: (~) ((,) a b) z ((,) a b n n) => Sing a n -> Sing b n -> Sing ((,) a b) z

data Sing ((,,) a0 b0 c0) where

• STuple3 :: (~) ((,,) a b c) z ((,,) a b c n n n) => Sing a n -> Sing b n -> Sing c n -> Sing ((,,) a b c) z

data Sing ((,,,) a0 b0 c0 d0) where

• STuple4 :: (~) ((,,,) a b c d) z ((,,,) a b c d n n n n) => Sing a n -> Sing b n -> Sing c n -> Sing d n -> Sing ((,,,) a b c d) z

data Sing ((,,,,) a0 b0 c0 d0 e0) where

• STuple5 :: (~) ((,,,,) a b c d e) z ((,,,,) a b c d e n n n n n) => Sing a n -> Sing b n -> Sing c n -> Sing d n -> Sing e n -> Sing ((,,,,) a b c d e) z

data Sing ((,,,,,) a0 b0 c0 d0 e0 f0) where

• STuple6 :: (~) ((,,,,,) a b c d e f) z ((,,,,,) a b c d e f n n n n n n) => Sing a n -> Sing b n -> Sing c n -> Sing d n -> Sing e n -> Sing f n -> Sing ((,,,,,) a b c d e f) z

data Sing ((,,,,,,) a0 b0 c0 d0 e0 f0 g0) where

• STuple7 :: (~) ((,,,,,,) a b c d e f g) z ((,,,,,,) a b c d e f g n n n n n n n) => Sing a n -> Sing b n -> Sing c n -> Sing d n -> Sing e n -> Sing f n -> Sing g n -> Sing ((,,,,,,) a b c d e f g) z

Though Haddock doesn't show it, the Sing instance above declares constructors

SLeft  :: Sing a -> Sing (Left a)
SRight :: Sing b -> Sing (Right b)

type SEither z = Sing z

SEither is a kind-restricted synonym for Sing: type SEither (a :: Either x y) = Sing a

Singletons from Data.Either

either_ :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c

type family Either_ a a a :: c

Equations

Either_ f z (Left x) = Apply f x

Either_ z g (Right y) = Apply g y

sEither_ :: forall t t t. Sing t -> Sing t -> Sing t -> Sing (Apply (Apply (Apply Either_Sym0 t) t) t)

The preceding two definitions are derived from the function either in Data.Either. The extra underscore is to avoid name clashes with the type Either.

type family Lefts a :: [a]

Equations

Lefts `[]` = `[]`

Lefts ((:) (Left x) xs) = Apply (Apply (:$) x) (Apply LeftsSym0 xs)

Lefts ((:) (Right z) xs) = Apply LeftsSym0 xs

sLefts :: forall t. Sing t -> Sing (Apply LeftsSym0 t)

type family Rights a :: [b]

Equations

Rights `[]` = `[]`

Rights ((:) (Left z) xs) = Apply RightsSym0 xs

Rights ((:) (Right x) xs) = Apply (Apply (:$) x) (Apply RightsSym0 xs)

sRights :: forall t. Sing t -> Sing (Apply RightsSym0 t)

type family PartitionEithers a :: ([a], [b])

Equations

PartitionEithers a_1627572110 = Apply (Apply (Apply FoldrSym0 (Apply (Apply Either_Sym0 (Let_1627572117LeftSym1 a_1627572110)) (Let_1627572117RightSym1 a_1627572110))) (Apply (Apply Tuple2Sym0 `[]`) `[]`)) a_1627572110

sPartitionEithers :: forall t. Sing t -> Sing (Apply PartitionEithersSym0 t)

type family IsLeft a :: Bool

Equations

IsLeft (Left z) = TrueSym0

IsLeft (Right z) = FalseSym0

sIsLeft :: forall t. Sing t -> Sing (Apply IsLeftSym0 t)

type family IsRight a :: Bool

Equations

IsRight (Left z) = FalseSym0

IsRight (Right z) = TrueSym0

sIsRight :: forall t. Sing t -> Sing (Apply IsRightSym0 t)

Defunctionalization symbols

data LeftSym0 l

Instances

SuppressUnusedWarnings (TyFun k (Either k k) -> *) (LeftSym0 k k)

type Apply (Either k k1) k (LeftSym0 k k1) l0 = LeftSym1 k k1 l0

type LeftSym1 t = Left t

data RightSym0 l

Instances

SuppressUnusedWarnings (TyFun k (Either k k) -> *) (RightSym0 k k)

type Apply (Either k1 k) k (RightSym0 k k1) l0 = RightSym1 k k1 l0

type RightSym1 t = Right t

data Either_Sym0 l

Instances

SuppressUnusedWarnings (TyFun (TyFun k k -> *) (TyFun (TyFun k k -> *) (TyFun (Either k k) k -> *) -> *) -> *) (Either_Sym0 k k k)

type Apply (TyFun (TyFun k2 k1 -> *) (TyFun (Either k k2) k1 -> *) -> *) (TyFun k k1 -> *) (Either_Sym0 k k1 k2) l0 = Either_Sym1 k k1 k2 l0

data Either_Sym1 l l

Instances

SuppressUnusedWarnings ((TyFun k k -> *) -> TyFun (TyFun k k -> *) (TyFun (Either k k) k -> *) -> *) (Either_Sym1 k k k)

type Apply (TyFun (Either k1 k) k2 -> *) (TyFun k k2 -> *) (Either_Sym1 k1 k2 k l1) l0 = Either_Sym2 k1 k2 k l1 l0

data Either_Sym2 l l l

Instances

SuppressUnusedWarnings ((TyFun k k -> *) -> (TyFun k k -> *) -> TyFun (Either k k) k -> *) (Either_Sym2 k k k)

type Apply k1 (Either k k2) (Either_Sym2 k k1 k2 l1 l2) l0 = Either_Sym3 k k1 k2 l1 l2 l0

type Either_Sym3 t t t = Either_ t t t

data LeftsSym0 l

Instances

SuppressUnusedWarnings (TyFun [Either k k] [k] -> *) (LeftsSym0 k k)

type Apply [k] [Either k k1] (LeftsSym0 k k1) l0 = LeftsSym1 k k1 l0

type LeftsSym1 t = Lefts t

data RightsSym0 l

Instances

SuppressUnusedWarnings (TyFun [Either k k] [k] -> *) (RightsSym0 k k)

type Apply [k] [Either k1 k] (RightsSym0 k1 k) l0 = RightsSym1 k1 k l0

type RightsSym1 t = Rights t

data IsLeftSym0 l

Instances

SuppressUnusedWarnings (TyFun (Either k k) Bool -> *) (IsLeftSym0 k k)

type Apply Bool (Either k k1) (IsLeftSym0 k k1) l0 = IsLeftSym1 k k1 l0

type IsLeftSym1 t = IsLeft t

data IsRightSym0 l

Instances

SuppressUnusedWarnings (TyFun (Either k k) Bool -> *) (IsRightSym0 k k)

type Apply Bool (Either k k1) (IsRightSym0 k k1) l0 = IsRightSym1 k k1 l0

type IsRightSym1 t = IsRight t