Data.Exists

Data types and type classes for working with existentially quantified values. In the event that Quantified Class Constraints ever land in GHC, this package will be considered obsolete. The benefit that most of the typeclasses in this module provide is that they help populate the instances of Exists.

Data Types

data Exists (f :: k -> Type)

Hide a type parameter.

Constructors

Exists !(f a)

Instances

BoundedForall f => Bounded (Exists f)

Defined in Data.Exists

Methods

minBound :: Exists f

maxBound :: Exists f

EnumForall f => Enum (Exists f)

Defined in Data.Exists

Methods

succ :: Exists f -> Exists f

pred :: Exists f -> Exists f

toEnum :: Int -> Exists f

fromEnum :: Exists f -> Int

enumFrom :: Exists f -> [Exists f]

enumFromThen :: Exists f -> Exists f -> [Exists f]

enumFromTo :: Exists f -> Exists f -> [Exists f]

enumFromThenTo :: Exists f -> Exists f -> Exists f -> [Exists f]

EqForallPoly f => Eq (Exists f)

Defined in Data.Exists

Methods

(==) :: Exists f -> Exists f -> Bool

(/=) :: Exists f -> Exists f -> Bool

OrdForallPoly f => Ord (Exists f)

Defined in Data.Exists

Methods

compare :: Exists f -> Exists f -> Ordering

(<) :: Exists f -> Exists f -> Bool

(<=) :: Exists f -> Exists f -> Bool

(>) :: Exists f -> Exists f -> Bool

(>=) :: Exists f -> Exists f -> Bool

max :: Exists f -> Exists f -> Exists f

min :: Exists f -> Exists f -> Exists f

ReadForall f => Read (Exists f)

Defined in Data.Exists

Methods

readsPrec :: Int -> ReadS (Exists f)

readList :: ReadS [Exists f]

readPrec :: ReadPrec (Exists f)

readListPrec :: ReadPrec [Exists f]

ShowForall f => Show (Exists f)

Defined in Data.Exists

Methods

showsPrec :: Int -> Exists f -> ShowS

show :: Exists f -> String

showList :: [Exists f] -> ShowS

HashableForall f => Hashable (Exists f)

Defined in Data.Exists

Methods

hashWithSalt :: Int -> Exists f -> Int

hash :: Exists f -> Int

ToJSONForall f => ToJSON (Exists f)

Defined in Data.Exists

Methods

toJSON :: Exists f -> Value

toEncoding :: Exists f -> Encoding

toJSONList :: [Exists f] -> Value

toEncodingList :: [Exists f] -> Encoding

(ToJSONKeyForall f, ToJSONForall f) => ToJSONKey (Exists f)

Defined in Data.Exists

Methods

toJSONKey :: ToJSONKeyFunction (Exists f)

toJSONKeyList :: ToJSONKeyFunction [Exists f]

FromJSONExists f => FromJSON (Exists f)

Defined in Data.Exists

Methods

parseJSON :: Value -> Parser (Exists f)

parseJSONList :: Value -> Parser [Exists f]

(FromJSONKeyExists f, FromJSONExists f) => FromJSONKey (Exists f)

Defined in Data.Exists

Methods

fromJSONKey :: FromJSONKeyFunction (Exists f)

fromJSONKeyList :: FromJSONKeyFunction [Exists f]

PathPieceForall f => PathPiece (Exists f)

Defined in Data.Exists

Methods

fromPathPiece :: Text -> Maybe (Exists f)

toPathPiece :: Exists f -> Text

data Exists2 (f :: k -> j -> Type)

Hide two type parameters.

Constructors

Exists2 !(f a b)

Instances

EqForallPoly2 f => Eq (Exists2 f)

Defined in Data.Exists

Methods

(==) :: Exists2 f -> Exists2 f -> Bool

(/=) :: Exists2 f -> Exists2 f -> Bool

ShowForall2 f => Show (Exists2 f)

Defined in Data.Exists

Methods

showsPrec :: Int -> Exists2 f -> ShowS

show :: Exists2 f -> String

showList :: [Exists2 f] -> ShowS

data Exists3 (f :: k -> j -> l -> Type)

Hide three type parameters.

Constructors

Exists3 !(f a b c)

data Some (f :: k -> Type)

Constructors

Some !(Sing a) !(f a)

Instances

(EqForall f, EqSing k) => Eq (Some f)

Defined in Data.Exists

Methods

(==) :: Some f -> Some f -> Bool

(/=) :: Some f -> Some f -> Bool

(ToJSONForall f, ToJSONSing k) => ToJSON (Some f)

Defined in Data.Exists

Methods

toJSON :: Some f -> Value

toEncoding :: Some f -> Encoding

toJSONList :: [Some f] -> Value

toEncodingList :: [Some f] -> Encoding

(FromJSONForall f, FromJSONSing k) => FromJSON (Some f)

Defined in Data.Exists

Methods

parseJSON :: Value -> Parser (Some f)

parseJSONList :: Value -> Parser [Some f]

data DependentPair (f :: k -> Type) (g :: k -> Type)

Constructors

DependentPair (f a) (g a)

Instances

(EqForallPoly f, ToSing f, EqForeach g) => Eq (DependentPair f g)

Defined in Data.Exists

Methods

(==) :: DependentPair f g -> DependentPair f g -> Bool

(/=) :: DependentPair f g -> DependentPair f g -> Bool

(OrdForallPoly f, ToSing f, OrdForeach g) => Ord (DependentPair f g)

Defined in Data.Exists

Methods

compare :: DependentPair f g -> DependentPair f g -> Ordering

(<) :: DependentPair f g -> DependentPair f g -> Bool

(<=) :: DependentPair f g -> DependentPair f g -> Bool

(>) :: DependentPair f g -> DependentPair f g -> Bool

(>=) :: DependentPair f g -> DependentPair f g -> Bool

max :: DependentPair f g -> DependentPair f g -> DependentPair f g

min :: DependentPair f g -> DependentPair f g -> DependentPair f g

(ShowForall f, ToSing f, ShowForeach g) => Show (DependentPair f g)

Defined in Data.Exists

Methods

showsPrec :: Int -> DependentPair f g -> ShowS

show :: DependentPair f g -> String

showList :: [DependentPair f g] -> ShowS

data WitnessedEquality (a :: k) (b :: k) where

Constructors

WitnessedEqualityEqual :: WitnessedEquality a a

WitnessedEqualityUnequal :: WitnessedEquality a b

data WitnessedOrdering (a :: k) (b :: k) where

Constructors

WitnessedOrderingLT :: WitnessedOrdering a b

WitnessedOrderingEQ :: WitnessedOrdering a a

WitnessedOrderingGT :: WitnessedOrdering a b

Type Classes

class EqForall f where

Minimal complete definition

eqForall

Methods

eqForall :: f a -> f a -> Bool

Instances

EqForall (Proxy :: k -> *)

Defined in Data.Exists

Methods

eqForall :: Proxy a -> Proxy a -> Bool

Eq a => EqForall (Const a :: k -> *)

Defined in Data.Exists

Methods

eqForall :: Const a a0 -> Const a a0 -> Bool

EqForall ((:~:) a :: k -> *)

Defined in Data.Exists

Methods

eqForall :: (a :~: a0) -> (a :~: a0) -> Bool

EqHetero h => EqForall (HFix h :: k -> *)

Defined in Topaz.Types

Methods

eqForall :: HFix h a -> HFix h a -> Bool

(EqForall f, EqForall g) => EqForall (Sum f g :: k -> *)

Defined in Data.Exists

Methods

eqForall :: Sum f g a -> Sum f g a -> Bool

(EqForall f, EqForall g) => EqForall (Product f g :: k -> *)

Defined in Data.Exists

Methods

eqForall :: Product f g a -> Product f g a -> Bool

(Eq1 f, EqForall g) => EqForall (Compose f g :: k -> *)

Defined in Data.Exists

Methods

eqForall :: Compose f g a -> Compose f g a -> Bool

EqForall f => EqForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

eqForall :: Rec f a -> Rec f a -> Bool

class EqForall f => EqForallPoly f where

Methods

eqForallPoly :: f a -> f b -> WitnessedEquality a b

eqForallPoly :: TestEquality f => f a -> f b -> WitnessedEquality a b

Instances

(EqForallPoly f, EqForallPoly g) => EqForallPoly (Product f g :: k -> *)

Defined in Data.Exists

Methods

eqForallPoly :: Product f g a -> Product f g b -> WitnessedEquality a b

class EqForeach f where

Variant of EqForall that requires a pi-quantified type.

Minimal complete definition

eqForeach

Methods

eqForeach :: Sing a -> f a -> f a -> Bool

class EqForall f => OrdForall f where

Minimal complete definition

compareForall

Methods

compareForall :: f a -> f a -> Ordering

Instances

OrdForall (Proxy :: k -> *)

Defined in Data.Exists

Methods

compareForall :: Proxy a -> Proxy a -> Ordering

Ord a => OrdForall (Const a :: k -> *)

Defined in Data.Exists

Methods

compareForall :: Const a a0 -> Const a a0 -> Ordering

(OrdForall f, OrdForall g) => OrdForall (Sum f g :: k -> *)

Defined in Data.Exists

Methods

compareForall :: Sum f g a -> Sum f g a -> Ordering

(OrdForall f, OrdForall g) => OrdForall (Product f g :: k -> *)

Defined in Data.Exists

Methods

compareForall :: Product f g a -> Product f g a -> Ordering

OrdForall f => OrdForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

compareForall :: Rec f a -> Rec f a -> Ordering

class (OrdForall f, EqForallPoly f) => OrdForallPoly f where

Minimal complete definition

compareForallPoly

Methods

compareForallPoly :: f a -> f b -> WitnessedOrdering a b

Instances

(OrdForallPoly f, OrdForallPoly g) => OrdForallPoly (Product f g :: k -> *)

Defined in Data.Exists

Methods

compareForallPoly :: Product f g a -> Product f g b -> WitnessedOrdering a b

class EqForeach f => OrdForeach f where

Variant of OrdForall that requires a pi-quantified type.

Minimal complete definition

compareForeach

Methods

compareForeach :: Sing a -> f a -> f a -> Ordering

class ShowForall f where

Minimal complete definition

showsPrecForall

Methods

showsPrecForall :: Int -> f a -> ShowS

Instances

ShowForall (Proxy :: k -> *)

Defined in Data.Exists

Methods

showsPrecForall :: Int -> Proxy a -> ShowS

(ShowForall f, ShowForall g) => ShowForall (Product f g :: k -> *)

Defined in Data.Exists

Methods

showsPrecForall :: Int -> Product f g a -> ShowS

(Show1 f, ShowForall g) => ShowForall (Compose f g :: k -> *)

Defined in Data.Exists

Methods

showsPrecForall :: Int -> Compose f g a -> ShowS

ShowForall f => ShowForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

showsPrecForall :: Int -> Rec f a -> ShowS

class ShowForeach f where

Minimal complete definition

showsPrecForeach

Methods

showsPrecForeach :: Sing a -> Int -> f a -> ShowS

class ReadForall f where

Minimal complete definition

readPrecForall

Methods

readPrecForall :: ReadPrec (Exists f)

Instances

ReadForall (Proxy :: k -> *)

Defined in Data.Exists

Methods

readPrecForall :: ReadPrec (Exists Proxy)

class EnumForall f where

Minimal complete definition

toEnumForall, fromEnumForall

Methods

toEnumForall :: Int -> Exists f

fromEnumForall :: f a -> Int

class BoundedForall f where

Minimal complete definition

minBoundForall, maxBoundForall

Methods

minBoundForall :: Exists f

maxBoundForall :: Exists f

class SemigroupForall f where

Minimal complete definition

sappendForall

Methods

sappendForall :: f a -> f a -> f a

Instances

SemigroupForall (Proxy :: k -> *)

Defined in Data.Exists

Methods

sappendForall :: Proxy a -> Proxy a -> Proxy a

SemigroupForall f => SemigroupForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

sappendForall :: Rec f a -> Rec f a -> Rec f a

class SemigroupForall f => MonoidForall f where

Minimal complete definition

memptyForall

Methods

memptyForall :: Sing a -> f a

Instances

MonoidForall f => MonoidForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

memptyForall :: Sing a -> Rec f a

class HashableForall f where

Minimal complete definition

hashWithSaltForall

Methods

hashWithSaltForall :: Int -> f a -> Int

Instances

Hashable a => HashableForall (Const a :: k -> *)

Defined in Data.Exists

Methods

hashWithSaltForall :: Int -> Const a a0 -> Int

HashableForall f => HashableForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

hashWithSaltForall :: Int -> Rec f a -> Int

class PathPieceForall f where

Minimal complete definition

fromPathPieceForall, toPathPieceForall

Methods

fromPathPieceForall :: Text -> Maybe (Exists f)

toPathPieceForall :: f a -> Text

class FromJSONForall f where

Minimal complete definition

parseJSONForall

Methods

parseJSONForall :: Sing a -> Value -> Parser (f a)

Instances

(FromJSON1 f, FromJSONForall g) => FromJSONForall (Compose f g :: k -> *)

Defined in Data.Exists

Methods

parseJSONForall :: Sing a -> Value -> Parser (Compose f g a)

FromJSONForall f => FromJSONForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

parseJSONForall :: Sing a -> Value -> Parser (Rec f a)

class FromJSONExists f where

Minimal complete definition

parseJSONExists

Methods

parseJSONExists :: Value -> Parser (Exists f)

Instances

FromJSONExists f => FromJSONExists (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

parseJSONExists :: Value -> Parser (Exists (Rec f))

class ToJSONForall f where

Minimal complete definition

toJSONForall

Methods

toJSONForall :: f a -> Value

Instances

(ToJSON1 f, ToJSONForall g) => ToJSONForall (Compose f g :: k -> *)

Defined in Data.Exists

Methods

toJSONForall :: Compose f g a -> Value

ToJSONForall f => ToJSONForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

toJSONForall :: Rec f a -> Value

data ToJSONKeyFunctionForall f

Constructors

ToJSONKeyTextForall !(forall a. f a -> Text) !(forall a. f a -> Encoding' Text)

ToJSONKeyValueForall !(forall a. f a -> Value) !(forall a. f a -> Encoding)

data FromJSONKeyFunctionForall f

Constructors

FromJSONKeyTextParserForall !(forall a. Sing a -> Text -> Parser (f a))

FromJSONKeyValueForall !(forall a. Sing a -> Value -> Parser (f a))

class ToJSONKeyForall f where

Minimal complete definition

toJSONKeyForall

Methods

toJSONKeyForall :: ToJSONKeyFunctionForall f

class FromJSONKeyExists f where

Minimal complete definition

fromJSONKeyExists

Methods

fromJSONKeyExists :: FromJSONKeyFunction (Exists f)

class FromJSONKeyForall f where

Minimal complete definition

fromJSONKeyForall

Methods

fromJSONKeyForall :: FromJSONKeyFunctionForall f

class StorableForall (f :: k -> Type) where

Minimal complete definition

peekForall, pokeForall, sizeOfFunctorForall, sizeOfForall

Methods

peekForall :: Sing a -> Ptr (f a) -> IO (f a)

pokeForall :: Ptr (f a) -> f a -> IO ()

sizeOfFunctorForall :: f a -> Int

sizeOfForall :: forall (a :: k). Proxy f -> Sing a -> Int

Instances

StorableForall f => StorableForall (Rec f :: [k] -> Type)

Defined in Topaz.Types

Methods

peekForall :: Sing a -> Ptr (Rec f a) -> IO (Rec f a)

pokeForall :: Ptr (Rec f a) -> Rec f a -> IO ()

sizeOfFunctorForall :: Rec f a -> Int

sizeOfForall :: Proxy (Rec f) -> Sing a -> Int

Higher Rank Classes

class EqForall2 f where

Minimal complete definition

eqForall2

Methods

eqForall2 :: f a b -> f a b -> Bool

Instances

EqForall2 ((:~:) :: k -> k -> *)

Defined in Data.Exists

Methods

eqForall2 :: (a :~: b) -> (a :~: b) -> Bool

class EqForallPoly2 f where

Minimal complete definition

eqForallPoly2

Methods

eqForallPoly2 :: f a b -> f c d -> Bool

class ShowForall2 f where

Minimal complete definition

showsPrecForall2

Methods

showsPrecForall2 :: Int -> f a b -> ShowS

More Type Classes

type family Sing = (r :: k -> Type) | r -> k

Instances

type Sing

Defined in Topaz.Types

type Sing = SingNat

type Sing

Defined in Data.Exists

type Sing = (SingList :: [k] -> Type)

type Sing

Defined in Data.Exists

type Sing = (SingMaybe :: Maybe k -> Type)

data SingList :: [k] -> Type where

Constructors

SingListNil :: SingList '[]

SingListCons :: Sing r -> SingList rs -> SingList (r ': rs)

data SingMaybe :: Maybe k -> Type where

Constructors

SingMaybeJust :: Sing a -> SingMaybe (Just a)

SingMaybeNothing :: SingMaybe Nothing

class Reify a where

Minimal complete definition

reify

Methods

reify :: Sing a

Instances

Reify ([] :: [k])

Defined in Data.Exists

Methods

reify :: Sing []

Reify (Nothing :: Maybe a)

Defined in Data.Exists

Methods

reify :: Sing Nothing

Reify a2 => Reify (Just a2 :: Maybe a1)

Defined in Data.Exists

Methods

reify :: Sing (Just a2)

(Reify a2, Reify as) => Reify (a2 ': as :: [a1])

Defined in Data.Exists

Methods

reify :: Sing (a2 ': as)

class Unreify k where

Minimal complete definition

unreify

Methods

unreify :: forall (a :: k) b. Sing a -> (Reify a => b) -> b

Instances

Unreify k => Unreify [k]

Defined in Data.Exists

Methods

unreify :: Sing a -> (Reify a -> b) -> b

Sing Type Classes

class EqSing k where

Minimal complete definition

eqSing

Methods

eqSing :: forall (a :: k) (b :: k). Sing a -> Sing b -> Maybe (a :~: b)

Instances

EqSing a => EqSing [a]

Defined in Data.Exists

Methods

eqSing :: Sing a0 -> Sing b -> Maybe (a0 :~: b)

class ToJSONSing k where

Minimal complete definition

toJSONSing

Methods

toJSONSing :: forall (a :: k). Sing a -> Value

class FromJSONSing k where

Minimal complete definition

parseJSONSing

Methods

parseJSONSing :: Value -> Parser (Exists (Sing :: k -> Type))

class ToSing (f :: k -> Type) where

Minimal complete definition

toSing

Methods

toSing :: f a -> Sing a

Functions

Show

showsForall :: ShowForall f => f a -> ShowS

showForall :: ShowForall f => f a -> String

showsForall2 :: ShowForall2 f => f a b -> ShowS

showForall2 :: ShowForall2 f => f a b -> String

Defaulting

defaultEqForallPoly :: (TestEquality f, EqForall f) => f a -> f b -> WitnessedEquality a b

defaultCompareForallPoly :: (TestEquality f, OrdForall f) => f a -> f b -> Ordering

parseJSONMapForallKey :: forall f a v. (FromJSONKeyForall f, OrdForall f) => (Value -> Parser v) -> Sing a -> Value -> Parser (Map (f a) v)

Parse a Map whose key type is higher-kinded. This only creates a valid Map if the OrdForall instance agrees with the Ord instance.

Weakening

weakenEquality :: WitnessedEquality a b -> Bool

weakenOrdering :: WitnessedOrdering a b -> Ordering

Other

unreifyList :: forall (as :: [k]) b. Unreify k => SingList as -> (Reify as => b) -> b