Data.Exists

Existential datatypes holding evidence of constraints, and type classes for existential datatypes.

For kind *

data Exists c where

A datatype which holds a value of a type satisfying the constraint c, hiding the type, and evidence for the constraint, so that it can be retrieved by pattern matching later.

Example:

 foo :: Exists Show
 foo = Exists (Just 9 :: Maybe Int)

 printExists :: Exists Show -> IO ()
 printExists (Exists e) = print e

 main = printExists foo -- prints "Just 9"

Constructors

Exists :: c a => a -> Exists c

Instances

Show (Exists Show)

Existential (Exists c)

ConstraintOf (Exists c) = c

class Existential e where

A type class to abstract over existential datatypes.

Example:

 data EShow where
      EShow :: Show a => a -> EShow

 instance Existential EShow where
     type ConstraintOf EShow = Show
     exists = EShow
     apply f (EShow a) = f a

 foo :: EShow
 foo = exists (Just 9 :: Maybe Int)

 main = apply print foo -- prints "Just 9"

Note that had we given foo the type signature

 foo :: (Existential e, ConstraintOf e ~ Show) => e

GHC would have given us an error message, because the instance of Existential to use would have been ambiguous. (The apply f . exists problem is the same as the show . read problem.)

Associated Types

type ConstraintOf e :: * -> Constraint

Methods

exists :: ConstraintOf e a => a -> e

Construct e from a value of a type satisfying the constraint.

apply :: (forall a. ConstraintOf e a => a -> r) -> e -> r

Apply a function requiring the constraint to the held value.

Instances

Existential Dynamic

ConstraintOf Dynamic = Typeable

Existential SomeException

ConstraintOf SomeException = Exception

Existential Anything

ConstraintOf Anything = Empty

Existential (Any *)

ConstraintOf Any = Empty

Existential (Exists c)

ConstraintOf (Exists c) = c

Existential (Exists c)

ConstraintOf (Exists c) = c

class (Existential e, c ~ ConstraintOf e) => ExistentialWith c e

An alias for convenience.

 foo :: ExistentialWith Show e => e -> IO ()

is equivalent to

 foo :: (Existential e, ConstraintOf e ~ Show) => e -> IO ()

Instances

(Existential e, ~ (* -> Constraint) c (ConstraintOf e)) => ExistentialWith c e

translate :: (ExistentialWith c e1, ExistentialWith c e2) => e1 -> e2

Translate between different existential datatypes holding evidence for the same constraint.

For kind * -> *

data Exists1 c a where

A * -> * kinded version of Exists which holds a value of a type constructor applied to a type, hiding the type constructor, and evidence for a constraint on the type constructor.

Constructors

Exists1 :: c f => f a -> Exists1 c a

Instances

Functor (Exists1 Functor)

Functor (Exists1 Traversable)

Foldable (Exists1 Foldable)

Foldable (Exists1 Traversable)

Traversable (Exists1 Traversable)

Contravariant (Exists1 Contravariant)

Existential1 (Exists1 c)

ConstraintOf1 (Exists1 c) = c

class Existential1 e where

A version of Existential for kind * -> *.

Associated Types

type ConstraintOf1 e :: (* -> *) -> Constraint

Methods

exists1 :: ConstraintOf1 e f => f a -> e a

Construct e from a value of a type constructor applied to a type, where the type constructor satisfies the constraint.

apply1 :: (forall f. ConstraintOf1 e f => f a -> r) -> e a -> r

Apply a function requiring the constraint to the held value.

Instances

Existential1 Anything1

ConstraintOf1 Anything1 = Empty

Existential1 (Any (* -> *))

ConstraintOf1 Any = Empty

Existential1 (Exists1 c)

ConstraintOf1 (Exists1 c) = c

Existential1 (Exists1 c)

ConstraintOf1 (Exists1 c) = c

class (Existential1 e, c ~ ConstraintOf1 e) => ExistentialWith1 c e

An alias for convenience. A version of ExistentialWith for kind * -> *.

Instances

(Existential1 e, ~ ((* -> *) -> Constraint) c (ConstraintOf1 e)) => ExistentialWith1 c e

translate1 :: (ExistentialWith1 c e1, ExistentialWith1 c e2) => e1 a -> e2 a

Translate between different existential datatypes holding evidence for the same constraint on a * -> * kinded type constructor.

The Constraint kind

data Constraint