Data.Singletons.Prelude.Void

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

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.Void. Also, please excuse the apparent repeated variable names. This is due to an interaction between Template Haskell and Haddock.

The Void singleton

data family Sing (a :: k)

The singleton kind-indexed data family.

Instances

data Sing (z :: Bool)

data Sing (z :: Bool) where

• SFalse :: Sing False
• STrue :: Sing True

data Sing (z :: Ordering)

data Sing (z :: Ordering) where

• SLT :: Sing LT
• SEQ :: Sing EQ
• SGT :: Sing GT

data Sing (a :: Type)

data Sing (a :: Type) = STypeRep (TypeRep a)

data Sing (n :: Nat)

data Sing (n :: Nat) where

• SNat :: Sing n

data Sing (n :: Symbol)

data Sing (n :: Symbol) where

• SSym :: Sing n

data Sing (z :: ())

data Sing (z :: ()) where

• STuple0 :: Sing ()

data Sing (z :: Void)

data Sing (z :: Void)

data Sing (z :: [a])

data Sing (z :: [a]) where

• SNil :: Sing ([] :: [k])
• SCons :: Sing (n ': n)

data Sing (z :: Maybe a)

data Sing (z :: Maybe a) where

• SNothing :: Sing (Nothing :: Maybe a)
• SJust :: Sing (Just n)

data Sing (z :: NonEmpty a)

data Sing (z :: NonEmpty a) where

• (:%|) :: Sing (n :| n)

data Sing (z :: Either a b)

data Sing (z :: Either a b) where

• SLeft :: Sing (Left n :: Either a b)
• SRight :: Sing (Right n :: Either a b)

data Sing (z :: (a, b))

data Sing (z :: (a, b)) where

• STuple2 :: Sing ((,) n n)

data Sing (f :: k1 ~> k2)

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

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

}

data Sing (z :: (a, b, c))

data Sing (z :: (a, b, c)) where

• STuple3 :: Sing ((,,) n n n)

data Sing (z :: (a, b, c, d))

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

• STuple4 :: Sing ((,,,) n n n n)

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

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

• STuple5 :: Sing ((,,,,) n n n n n)

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

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

• STuple6 :: Sing ((,,,,,) n n n n n n)

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

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

• STuple7 :: Sing ((,,,,,,) n n n n n n n)

Just as Void has no constructors, the Sing instance above also has no constructors.

type SVoid = (Sing :: Void -> Type)

SVoid is a kind-restricted synonym for Sing: type SVoid (a :: Void) = Sing a

Singletons from Data.Void

type family Absurd (a :: Void) :: a where ...

Equations

Absurd a = Case_6989586621679285240 a a

sAbsurd :: forall (t :: Void). Sing t -> Sing (Apply AbsurdSym0 t :: a)

Defunctionalization symbols

data AbsurdSym0 (l :: TyFun Void a6989586621679285232)

Instances

SuppressUnusedWarnings (AbsurdSym0 :: TyFun Void a6989586621679285232 -> *)

Methods

suppressUnusedWarnings :: ()

type Apply (AbsurdSym0 :: TyFun Void k2 -> *) (l :: Void)

type Apply (AbsurdSym0 :: TyFun Void k2 -> *) (l :: Void) = (Absurd l :: k2)

type AbsurdSym1 (t :: Void) = Absurd t