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

Hide a type parameter.

Constructors

Exists !(f a)

Instances

BoundedForall k f => Bounded (Exists k f)

Methods

minBound :: Exists k f

maxBound :: Exists k f

EnumForall k f => Enum (Exists k f)

Methods

succ :: Exists k f -> Exists k f

pred :: Exists k f -> Exists k f

toEnum :: Int -> Exists k f

fromEnum :: Exists k f -> Int

enumFrom :: Exists k f -> [Exists k f]

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

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

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

EqForallPoly k f => Eq (Exists k f)

Methods

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

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

OrdForallPoly k f => Ord (Exists k f)

Methods

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

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

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

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

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

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

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

ReadForall k f => Read (Exists k f)

Methods

readsPrec :: Int -> ReadS (Exists k f)

readList :: ReadS [Exists k f]

readPrec :: ReadPrec (Exists k f)

readListPrec :: ReadPrec [Exists k f]

ShowForall k f => Show (Exists k f)

Methods

showsPrec :: Int -> Exists k f -> ShowS

show :: Exists k f -> String

showList :: [Exists k f] -> ShowS

HashableForall k f => Hashable (Exists k f)

Methods

hashWithSalt :: Int -> Exists k f -> Int

hash :: Exists k f -> Int

FromJSONExists k f => FromJSON (Exists k f)

Methods

parseJSON :: Value -> Parser (Exists k f)

parseJSONList :: Value -> Parser [Exists k f]

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

Methods

fromJSONKey :: FromJSONKeyFunction (Exists k f)

fromJSONKeyList :: FromJSONKeyFunction [Exists k f]

ToJSONForall k f => ToJSON (Exists k f)

Methods

toJSON :: Exists k f -> Value

toEncoding :: Exists k f -> Encoding

toJSONList :: [Exists k f] -> Value

toEncodingList :: [Exists k f] -> Encoding

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

Methods

toJSONKey :: ToJSONKeyFunction (Exists k f)

toJSONKeyList :: ToJSONKeyFunction [Exists k f]

PathPieceForall k f => PathPiece (Exists k f)

Methods

fromPathPiece :: Text -> Maybe (Exists k f)

toPathPiece :: Exists k f -> Text

data Exists2 f

Constructors

Exists2 !(f a b)

Instances

EqForallPoly2 j k f => Eq (Exists2 j k f)

Methods

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

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

ShowForall2 j k f => Show (Exists2 j k f)

Methods

showsPrec :: Int -> Exists2 j k f -> ShowS

show :: Exists2 j k f -> String

showList :: [Exists2 j k f] -> ShowS

data Exists3 f

Constructors

Exists3 !(f a b c)

data Some f

Constructors

Some !(Sing a) !(f a)

Instances

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

Methods

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

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

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

Methods

parseJSON :: Value -> Parser (Some k2 f)

parseJSONList :: Value -> Parser [Some k2 f]

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

Methods

toJSON :: Some k2 f -> Value

toEncoding :: Some k2 f -> Encoding

toJSONList :: [Some k2 f] -> Value

toEncodingList :: [Some k2 f] -> Encoding

Type Classes

class EqForall f where

Minimal complete definition

eqForall

Methods

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

Instances

EqForall k (Proxy k)

Methods

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

Eq a => EqForall k (Const k a)

Methods

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

EqForall k ((:~:) k a)

Methods

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

EqHetero k k h => EqForall k (HFix k h)

Methods

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

(EqForall k f, EqForall k g) => EqForall k (Sum k f g)

Methods

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

(EqForall k f, EqForall k g) => EqForall k (Product k f g)

Methods

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

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

Methods

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

EqForall k f => EqForall [k] (Rec k f)

Methods

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

class EqForall f => EqForallPoly f where

Methods

eqForallPoly :: f a -> f b -> Bool

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

Instances

Eq a => EqForallPoly k (Const k a)

Methods

eqForallPoly :: f a -> f b -> Bool

(EqForallPoly k f, EqForallPoly k g) => EqForallPoly k (Product k f g)

Methods

eqForallPoly :: f a -> f b -> Bool

(Eq1 f, EqForallPoly k g) => EqForallPoly k (Compose k * f g)

Methods

eqForallPoly :: f a -> f b -> Bool

class EqForall f => OrdForall f where

Minimal complete definition

compareForall

Methods

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

Instances

OrdForall k (Proxy k)

Methods

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

Ord a => OrdForall k (Const k a)

Methods

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

(OrdForall k f, OrdForall k g) => OrdForall k (Sum k f g)

Methods

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

(OrdForall k f, OrdForall k g) => OrdForall k (Product k f g)

Methods

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

OrdForall k f => OrdForall [k] (Rec k f)

Methods

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

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

Methods

compareForallPoly :: f a -> f b -> Ordering

compareForallPoly :: TestEquality f => f a -> f b -> Ordering

Instances

Ord a => OrdForallPoly k (Const k a)

Methods

compareForallPoly :: f a -> f b -> Ordering

(OrdForallPoly k f, OrdForallPoly k g) => OrdForallPoly k (Product k f g)

Methods

compareForallPoly :: f a -> f b -> Ordering

class ShowForall f where

Minimal complete definition

showsPrecForall

Methods

showsPrecForall :: Int -> f a -> ShowS

Instances

ShowForall k (Proxy k)

Methods

showsPrecForall :: Int -> f a -> ShowS

(ShowForall k f, ShowForall k g) => ShowForall k (Product k f g)

Methods

showsPrecForall :: Int -> f a -> ShowS

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

Methods

showsPrecForall :: Int -> f a -> ShowS

ShowForall k f => ShowForall [k] (Rec k f)

Methods

showsPrecForall :: Int -> f a -> ShowS

class ReadForall f where

Minimal complete definition

readPrecForall

Methods

readPrecForall :: ReadPrec (Exists f)

Instances

ReadForall k (Proxy k)

Methods

readPrecForall :: ReadPrec (Exists (Proxy k) f)

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 k (Proxy k)

Methods

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

SemigroupForall k f => SemigroupForall [k] (Rec k f)

Methods

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

class SemigroupForall f => MonoidForall f where

Minimal complete definition

memptyForall

Methods

memptyForall :: Sing a -> f a

Instances

MonoidForall k f => MonoidForall [k] (Rec k f)

Methods

memptyForall :: Sing (Rec k f) a -> f a

class HashableForall f where

Minimal complete definition

hashWithSaltForall

Methods

hashWithSaltForall :: Int -> f a -> Int

Instances

Hashable a => HashableForall k (Const k a)

Methods

hashWithSaltForall :: Int -> f a -> Int

HashableForall k f => HashableForall [k] (Rec k f)

Methods

hashWithSaltForall :: Int -> 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 k g) => FromJSONForall k (Compose k * f g)

Methods

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

FromJSONForall k f => FromJSONForall [k] (Rec k f)

Methods

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

class FromJSONExists f where

Minimal complete definition

parseJSONExists

Methods

parseJSONExists :: Value -> Parser (Exists f)

Instances

FromJSONExists k f => FromJSONExists [k] (Rec k f)

Methods

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

class ToJSONForall f where

Minimal complete definition

toJSONForall

Methods

toJSONForall :: f a -> Value

Instances

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

Methods

toJSONForall :: f a -> Value

ToJSONForall k f => ToJSONForall [k] (Rec k f)

Methods

toJSONForall :: 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 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. Proxy f -> Sing a -> Int

Instances

StorableForall k f => StorableForall [k] (Rec k f)

Methods

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

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

sizeOfFunctorForall :: f a -> Int

sizeOfForall :: Proxy (Rec k f -> Type) f -> Sing (Rec k f) 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 ((:~:) k)

Methods

eqForall2 :: f a b -> f 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 [k]

type Sing [k] = SingList k

type Sing (Maybe k)

type Sing (Maybe k) = SingMaybe k

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] ([] k)

Methods

reify :: Sing [k] a

Reify (Maybe a) (Nothing a)

Methods

reify :: Sing (Nothing a) a

Reify a a1 => Reify (Maybe a) (Just a a1)

Methods

reify :: Sing (Just a a1) a

(Reify a a1, Reify [a] as) => Reify [a] ((:) a a1 as)

Methods

reify :: Sing ((a ': a1) as) a

class Unreify k where

Minimal complete definition

unreify

Methods

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

Instances

Unreify k => Unreify [k]

Methods

unreify :: Sing [k] a -> (Reify [k] a -> b) -> b

Sing Type Classes

class EqSing k where

Minimal complete definition

eqSing

Methods

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

Instances

EqSing a => EqSing [a]

Methods

eqSing :: Sing [a] a -> Sing [a] b -> Maybe (([a] :~: a) b)

class ToJSONSing k where

Minimal complete definition

toJSONSing

Methods

toJSONSing :: forall a. Sing a -> Value

class FromJSONSing k where

Minimal complete definition

parseJSONSing

Methods

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

class ToSing f 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 -> Bool

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.

Other

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