-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Useful type level operations (type families and related operators).
--   
--   Useful type level operations (type families and related operators).
@package typelevel
@version 1.2.2

module Data.Constraint.Struct

module Data.Constraints

module Data.Proxify
proxify :: a -> Proxy (Proxified a)

module Type.Any

module Type.Bool
type a && b = And a b
class KnownBool (b :: Bool)
boolVal :: KnownBool b => Proxy b -> Bool
instance Type.Bool.KnownBool 'GHC.Types.True
instance Type.Bool.KnownBool 'GHC.Types.False

module Constraint.Container.Homo

module Type.Container
type UnsafeIndex el cont = FromJust (Index el cont)

module Type.Either

module Type.Error
type ErrMsg =  'Text
class TypeErrorIf (ok :: Bool) (err :: ErrorMessage)
type TypeAssert ok = TypeErrorIf ok (ErrMsg "Assertion failed.")
type Sentence a = a :<>: ErrMsg "."
type Ticked a = Between' "`" a
type Parensed a = Between "(" ")" a
type Between l r a = (ErrMsg l :<>: a) :<>: ErrMsg r
type Between' s a = Between s s a
type a :</>: b = (a :<>: ErrMsg " ") :<>: b
instance Type.Error.TypeErrorIf 'GHC.Types.True err
instance (TypeError ...) => Type.Error.TypeErrorIf 'GHC.Types.False err

module Type.Error_old
type ErrMsg =  'Text
class Assert (ok :: Bool) (err :: ErrorMessage)
type Assert' ok = Assert ok (ErrMsg "Assertion failed.")
type Sentence a = a :<>: ErrMsg "."
type Ticked a = Between' "`" a
type Parensed a = Between "(" ")" a
type Between l r a = (ErrMsg l :<>: a) :<>: ErrMsg r
type Between' s a = Between s s a
type a :</>: b = (a :<>: ErrMsg " ") :<>: b
instance Type.Error_old.Assert 'GHC.Types.True err
instance (TypeError ...) => Type.Error_old.Assert 'GHC.Types.False err

module Type.Functor
type f <$> as = FMap f as

module Type.Hidden
class Hidden t
hide :: Hidden t => a -> t
reveal :: Hidden t => t -> a
data Any
[Any] :: a -> Any
instance GHC.Show.Show Type.Hidden.Any
instance Type.Hidden.Hidden Type.Hidden.Any

module Type.Inference

-- | The Inferable type class describes a monad with a functional
--   dependency on the given type. It allows for writing polymorphic code
--   and ensuring Haskell that the type will be resolved while evaluating
--   the monadic stack.
type KnownType cls t = KnownTypeT cls t Identity
newtype KnownTypeT (cls :: ck) (t :: tk) (m :: * -> *) (a :: *)
KnownTypeT :: (IdentityT m a) -> KnownTypeT
inferT :: forall cls t m a. KnownTypeT cls t m a -> m a
instance forall tk1 ck1 tk2 ck2 (cls1 :: ck2) (t1 :: tk2) (m1 :: * -> *) a1 t2 (cls2 :: ck1) (t3 :: tk1) (m2 :: * -> *) a2. Type.Inference.KnownTypeT cls1 t1 m1 a1 ~ t2 => Control.Lens.Wrapped.Rewrapped (Type.Inference.KnownTypeT cls2 t3 m2 a2) t2
instance forall tk ck (cls :: ck) (t :: tk) (m :: * -> *) a. Control.Lens.Wrapped.Wrapped (Type.Inference.KnownTypeT cls t m a)
instance forall tk ck (m :: * -> *) (cls :: ck) (t :: tk). Control.Monad.Primitive.PrimMonad m => Control.Monad.Primitive.PrimMonad (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). GHC.Base.Alternative m => GHC.Base.Alternative (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). GHC.Base.Applicative m => GHC.Base.Applicative (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk). Control.Monad.Trans.Class.MonadTrans (Type.Inference.KnownTypeT cls t)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). GHC.Base.Monad m => GHC.Base.Monad (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *). GHC.Base.Functor m => GHC.Base.Functor (Type.Inference.KnownTypeT cls t m)
instance forall ck (cls :: ck) tk (t :: tk) (m :: * -> *) a. (GHC.Show.Show a, Data.Functor.Classes.Show1 m) => GHC.Show.Show (Type.Inference.KnownTypeT cls t m a)

module Type.Known
class KnownType t
fromType :: KnownType t => KnownTypeVal t
fromType' :: forall t s. (KnownType t, Convertible' (KnownTypeVal t) s) => s
instance GHC.TypeNats.KnownNat t => Type.Known.KnownType t
instance GHC.TypeLits.KnownSymbol t => Type.Known.KnownType t

module Type.Map
data Map k v
Map :: [(k, v)] -> Map k v

module Type.Maybe

module Type.Monoid
type a <> b = Concat a b

module Type.Applicative
type a <*> b = AppBind a b


-- | <i>Deprecated: Use Type.Known instead</i>
module Type.Promotion
class Known (t :: k) (val :: *)
typeVal :: Known t val => Proxy t -> val
class KnownNats (nats :: [Nat])
natVals :: KnownNats nats => Proxy nats -> [Integer]
instance Type.Promotion.KnownNats '[]
instance (GHC.TypeNats.KnownNat n, Type.Promotion.KnownNats ns) => Type.Promotion.KnownNats (n : ns)
instance (GHC.Num.Num i, GHC.TypeNats.KnownNat t) => Type.Promotion.Known t i
instance val ~ GHC.Types.Bool => Type.Promotion.Known 'GHC.Types.True val
instance val ~ GHC.Types.Bool => Type.Promotion.Known 'GHC.Types.False val
instance val ~ GHC.Base.Maybe a2 => Type.Promotion.Known 'GHC.Base.Nothing val
instance forall a1 val a2 (t :: a1). (val ~ GHC.Base.Maybe a2, Type.Promotion.Known t a2) => Type.Promotion.Known ('GHC.Base.Just t) val
instance forall b a val l r (t :: a). (val ~ Data.Either.Either l r, Type.Promotion.Known t l) => Type.Promotion.Known ('Data.Either.Left t) val
instance forall a b val l r (t :: b). (val ~ Data.Either.Either l r, Type.Promotion.Known t r) => Type.Promotion.Known ('Data.Either.Right t) val
instance Type.Promotion.Known '[] [a]
instance forall a1 (t :: a1) a2 (ts :: [a1]). (Type.Promotion.Known t a2, Type.Promotion.Known ts [a2]) => Type.Promotion.Known (t : ts) [a2]

module Type.Relation
type SemiSuper a = a : Super a

module Type.Sequence

module Type.Show
class Typeable a => TypeShow a
showType :: TypeShow a => String
printType :: forall a m. (TypeShow a, MonadIO m) => m ()
ppPrintType :: forall a m. (TypeShow a, MonadIO m) => m ()
ppShowType :: forall a. TypeShow a => String
ppTypeDoc :: forall a. TypeShow a => Doc
class ListElemsShow a
showListElems :: ListElemsShow a => String
instance forall k (a :: [k]). (Type.Show.ListElemsShow a, Data.Typeable.Internal.Typeable a) => Type.Show.TypeShow a
instance Type.Show.ListElemsShow '[]
instance forall k (a :: k). Type.Show.TypeShow a => Type.Show.ListElemsShow '[a]
instance forall a1 (a2 :: a1) (as :: [a1]). (Type.Show.TypeShow a2, Type.Show.ListElemsShow as) => Type.Show.ListElemsShow (a2 : as)
instance forall k (a :: k). Data.Typeable.Internal.Typeable a => Type.Show.TypeShow a
instance GHC.TypeNats.KnownNat n => Type.Show.TypeShow n
instance forall k1 k2 (a :: k2) (b :: k1). (Type.Show.TypeShow a, Type.Show.TypeShow b, Data.Typeable.Internal.Typeable '(a, b)) => Type.Show.TypeShow '(a, b)

module Type.Show_old
class TypeShow a
showType :: TypeShow a => Proxy a -> String
showType :: (TypeShow a, Typeable a) => Proxy a -> String
showType' :: forall t. TypeShow t => String
printType :: TypeShow a => Proxy a -> IO ()
ppPrintType :: TypeShow a => Proxy a -> IO ()
ppShowType :: TypeShow a => Proxy a -> String
ppTypeDoc :: TypeShow a => Proxy a -> Doc
class ListElemsShow a
showListElems :: ListElemsShow a => Proxy a -> String
instance forall k (a :: [k]). Type.Show_old.ListElemsShow a => Type.Show_old.TypeShow a
instance Type.Show_old.ListElemsShow '[]
instance forall k (a :: k). Type.Show_old.TypeShow a => Type.Show_old.ListElemsShow '[a]
instance forall a1 (a2 :: a1) (as :: [a1]). (Type.Show_old.TypeShow a2, Type.Show_old.ListElemsShow as) => Type.Show_old.ListElemsShow (a2 : as)
instance GHC.TypeNats.KnownNat n => Type.Show_old.TypeShow n
instance forall k1 k2 (a :: k2) (b :: k1). (Type.Show_old.TypeShow a, Type.Show_old.TypeShow b) => Type.Show_old.TypeShow '(a, b)

module Type.Wrapped

module Type.Operators

-- | The <a>$$</a> operator is just like <a>$</a> one but with even lower
--   precedence level. Unlike value-level <a>$</a>, the type-level one has
--   precedence level of `infixr 1` in order to be used in function
--   arguments, like `edge :: Node $ Source a -&gt; Node $ Target a -&gt;
--   a`. The <a>$$</a> operator has higher precedence than `-&gt;`, so the
--   above expression would not be valid when using it.
type f $$ a = f a
type f $ a = f a
type a & f = f a

module Type.Set
data Set (a :: [k])

module Type.List
data Lst (l :: [k])
data Recursive a
type Zip a b = Zip2 a b

module Type.Zip