Copyright	(C) 2013-2014 Richard Eisenberg, Jan Stolarek
License	BSD-style (see LICENSE)
Maintainer	Richard Eisenberg (eir@cis.upenn.edu)
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Data.Singletons.Prelude.Either

Contents

The Either singleton
Singletons from Data.Either
Defunctionalization symbols

Description

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.

Synopsis

The `Either` singleton

data family Sing a Source

The singleton kind-indexed data family.

Instances

data Sing Bool where SFalse :: (~) Bool z False => Sing Bool z STrue :: (~) Bool z True => Sing Bool z Source
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 Source
data Sing * where STypeRep :: Typeable * a => Sing * a Source
data Sing Nat where SNat :: KnownNat n => Sing Nat n Source
data Sing Symbol where SSym :: KnownSymbol n => Sing Symbol n Source
data Sing () where STuple0 :: (~) () z () => Sing () z Source
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 Source
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 Source
data Sing (TyFun k1 k2 -> *) = SLambda { applySing :: forall t. Sing k1 t -> Sing k2 ((@@) k2 k1 f t) } Source
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 Source
data Sing ((,) a0 b0) where STuple2 :: (~) ((,) a b) z ((,) a b n n) => Sing a n -> Sing b n -> Sing ((,) a b) z Source
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 Source
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 Source
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 Source
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 Source
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 Source

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 = (Sing :: Either a b -> *) Source

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 Source

type family Either_ a a a :: c Source

Equations

Either_ f _z_1627652955 (Left x) = Apply f x
Either_ _z_1627652959 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 :: c) Source

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] Source

Equations

Lefts `[]` = `[]`
Lefts ((:) (Left x) xs) = Apply (Apply (:$) x) (Apply LeftsSym0 xs)
Lefts ((:) (Right _z_1627654406) xs) = Apply LeftsSym0 xs

sLefts :: forall t. Sing t -> Sing (Apply LeftsSym0 t :: [a]) Source

type family Rights a :: [b] Source

Equations

Rights `[]` = `[]`
Rights ((:) (Left _z_1627654394) xs) = Apply RightsSym0 xs
Rights ((:) (Right x) xs) = Apply (Apply (:$) x) (Apply RightsSym0 xs)

sRights :: forall t. Sing t -> Sing (Apply RightsSym0 t :: [b]) Source

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

Equations

PartitionEithers a_1627654348 = Apply (Apply (Apply FoldrSym0 (Apply (Apply Either_Sym0 (Let1627654355LeftSym1 a_1627654348)) (Let1627654355RightSym1 a_1627654348))) (Apply (Apply Tuple2Sym0 `[]`) `[]`)) a_1627654348

sPartitionEithers :: forall t. Sing t -> Sing (Apply PartitionEithersSym0 t :: ([a], [b])) Source

type family IsLeft a :: Bool Source

Equations

IsLeft (Left _z_1627654342) = TrueSym0
IsLeft (Right _z_1627654345) = FalseSym0

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

type family IsRight a :: Bool Source

Equations

IsRight (Left _z_1627654332) = FalseSym0
IsRight (Right _z_1627654335) = TrueSym0

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

Defunctionalization symbols

data LeftSym0 l Source

Instances

SuppressUnusedWarnings (TyFun k (Either k k) -> *) (LeftSym0 k k) Source
type Apply (Either k k1) k (LeftSym0 k k1) l0 = LeftSym1 k k1 l0 Source

type LeftSym1 t = Left t Source

data RightSym0 l Source

Instances

SuppressUnusedWarnings (TyFun k (Either k k) -> *) (RightSym0 k k) Source
type Apply (Either k1 k) k (RightSym0 k1 k) l0 = RightSym1 k k1 l0 Source

type RightSym1 t = Right t Source

data Either_Sym0 l Source

Instances

SuppressUnusedWarnings (TyFun (TyFun k k -> ) (TyFun (TyFun k k -> ) (TyFun (Either k k) k -> ) -> ) -> *) (Either_Sym0 k k k) Source
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 Source

data Either_Sym1 l l Source

Instances

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

data Either_Sym2 l l l Source

Instances

SuppressUnusedWarnings ((TyFun k k -> ) -> (TyFun k k -> ) -> TyFun (Either k k) k -> *) (Either_Sym2 k k k) Source
type Apply k1 (Either k k2) (Either_Sym2 k k1 k2 l1 l2) l0 = Either_Sym3 k k1 k2 l1 l2 l0 Source

type Either_Sym3 t t t = Either_ t t t Source

data LeftsSym0 l Source

Instances

SuppressUnusedWarnings (TyFun [Either k k] [k] -> *) (LeftsSym0 k k) Source
type Apply [k] [Either k k1] (LeftsSym0 k k1) l0 = LeftsSym1 k k1 l0 Source

type LeftsSym1 t = Lefts t Source

data RightsSym0 l Source

Instances

SuppressUnusedWarnings (TyFun [Either k k] [k] -> *) (RightsSym0 k k) Source
type Apply [k] [Either k1 k] (RightsSym0 k1 k) l0 = RightsSym1 k1 k l0 Source

type RightsSym1 t = Rights t Source

data IsLeftSym0 l Source

Instances

SuppressUnusedWarnings (TyFun (Either k k) Bool -> *) (IsLeftSym0 k k) Source
type Apply Bool (Either k k1) (IsLeftSym0 k k1) l0 = IsLeftSym1 k k1 l0 Source

type IsLeftSym1 t = IsLeft t Source

data IsRightSym0 l Source

Instances

SuppressUnusedWarnings (TyFun (Either k k) Bool -> *) (IsRightSym0 k k) Source
type Apply Bool (Either k k1) (IsRightSym0 k k1) l0 = IsRightSym1 k k1 l0 Source

type IsRightSym1 t = IsRight t Source

The Either singleton

Singletons from Data.Either

Defunctionalization symbols

The `Either` singleton

Singletons from `Data.Either`