Data.Parameterized.Classes

This module declares classes for working with types with the kind k -> * for any kind k. These are generalizations of the Data.Functor.Classes types as they work with any kind k, and are not restricted to *.

Equality exports

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

This class contains types where you can learn the equality of two types from information contained in terms. Typically, only singleton types should inhabit this class.

Methods

testEquality :: f a -> f b -> Maybe (a :~: b)

Conditionally prove the equality of a and b.

Instances

TestEquality BoolRepr

Defined in Data.Parameterized.BoolRepr

Methods

testEquality :: BoolRepr a -> BoolRepr b -> Maybe (a :~: b)

TestEquality NatRepr

Defined in Data.Parameterized.NatRepr.Internal

Methods

testEquality :: NatRepr a -> NatRepr b -> Maybe (a :~: b)

TestEquality SymbolRepr

Defined in Data.Parameterized.SymbolRepr

Methods

testEquality :: SymbolRepr a -> SymbolRepr b -> Maybe (a :~: b)

TestEquality PeanoRepr

Defined in Data.Parameterized.Peano

Methods

testEquality :: PeanoRepr a -> PeanoRepr b -> Maybe (a :~: b)

TestEquality (Nonce :: k -> Type)

Defined in Data.Parameterized.Nonce.Unsafe

Methods

testEquality :: Nonce a -> Nonce b -> Maybe (a :~: b)

TestEquality (TypeRep :: k -> Type)

Defined in Data.Typeable.Internal

Methods

testEquality :: TypeRep a -> TypeRep b -> Maybe (a :~: b)

TestEquality (Nonce s :: k -> Type)

Defined in Data.Parameterized.Nonce

Methods

testEquality :: Nonce s a -> Nonce s b -> Maybe (a :~: b)

TestEquality ((:~:) a :: k -> Type)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

testEquality :: (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b)

TestEquality (Index l :: k -> Type)

Defined in Data.Parameterized.List

Methods

testEquality :: Index l a -> Index l b -> Maybe (a :~: b)

TestEquality (Index ctx :: k -> Type)

Defined in Data.Parameterized.Context.Unsafe

Methods

testEquality :: Index ctx a -> Index ctx b -> Maybe (a :~: b)

TestEquality (Index ctx :: k -> Type)

Defined in Data.Parameterized.Context.Safe

Methods

testEquality :: Index ctx a -> Index ctx b -> Maybe (a :~: b)

TestEquality ((:~~:) a :: k -> Type)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

testEquality :: (a :~~: a0) -> (a :~~: b) -> Maybe (a0 :~: b)

TestEquality f => TestEquality (Compose f g :: k1 -> Type)

Defined in Data.Parameterized.Compose

Methods

testEquality :: Compose f g a -> Compose f g b -> Maybe (a :~: b)

TestEquality f => TestEquality (List f :: [k] -> Type)

Defined in Data.Parameterized.List

Methods

testEquality :: List f a -> List f b -> Maybe (a :~: b)

TestEquality f => TestEquality (Assignment f :: Ctx k -> Type)

Defined in Data.Parameterized.Context.Unsafe

Methods

testEquality :: Assignment f a -> Assignment f b -> Maybe (a :~: b)

TestEquality f => TestEquality (Assignment f :: Ctx k -> Type)

Defined in Data.Parameterized.Context.Safe

Methods

testEquality :: Assignment f a -> Assignment f b -> Maybe (a :~: b)

data (a :: k) :~: (b :: k) :: forall k. k -> k -> Type where infix 4

Propositional equality. If a :~: b is inhabited by some terminating value, then the type a is the same as the type b. To use this equality in practice, pattern-match on the a :~: b to get out the Refl constructor; in the body of the pattern-match, the compiler knows that a ~ b.

Since: base-4.7.0.0

Constructors

Refl :: forall k (a :: k) (b :: k). a :~: a

Instances

Category ((:~:) :: k -> k -> Type)

Since: base-4.7.0.0

Defined in Control.Category

Methods

id :: a :~: a

(.) :: (b :~: c) -> (a :~: b) -> a :~: c

TestEquality ((:~:) a :: k -> Type)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

testEquality :: (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b)

NFData2 ((:~:) :: Type -> Type -> Type)

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf2 :: (a -> ()) -> (b -> ()) -> (a :~: b) -> ()

NFData1 ((:~:) a)

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a0 -> ()) -> (a :~: a0) -> ()

a ~ b => Bounded (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

minBound :: a :~: b

maxBound :: a :~: b

a ~ b => Enum (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

succ :: (a :~: b) -> a :~: b

pred :: (a :~: b) -> a :~: b

toEnum :: Int -> a :~: b

fromEnum :: (a :~: b) -> Int

enumFrom :: (a :~: b) -> [a :~: b]

enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b]

enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b]

enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b]

Eq (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

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

(/=) :: (a :~: b) -> (a :~: b) -> Bool

(a ~ b, Data a) => Data (a :~: b)

Since: base-4.7.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~: b) -> c (a :~: b)

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~: b)

toConstr :: (a :~: b) -> Constr

dataTypeOf :: (a :~: b) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~: b))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~: b))

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~: b) -> a :~: b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r

gmapQ :: (forall d. Data d => d -> u) -> (a :~: b) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~: b) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b)

Ord (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

compare :: (a :~: b) -> (a :~: b) -> Ordering

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

(<=) :: (a :~: b) -> (a :~: b) -> Bool

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

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

max :: (a :~: b) -> (a :~: b) -> a :~: b

min :: (a :~: b) -> (a :~: b) -> a :~: b

a ~ b => Read (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

readsPrec :: Int -> ReadS (a :~: b)

readList :: ReadS [a :~: b]

readPrec :: ReadPrec (a :~: b)

readListPrec :: ReadPrec [a :~: b]

Show (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

showsPrec :: Int -> (a :~: b) -> ShowS

show :: (a :~: b) -> String

showList :: [a :~: b] -> ShowS

NFData (a :~: b)

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

rnf :: (a :~: b) -> ()

class EqF (f :: k -> *) where

EqF provides a method eqF for testing whether two parameterized types are equal.

Unlike TestEquality, this only works when the type arguments are the same, and does not provide a proof that the types have the same type when they are equal. Thus this can be implemented over parameterized types that are unable to provide evidence that their type arguments are equal.

Methods

eqF :: f a -> f a -> Bool

Instances

Eq a => EqF (Const a :: k -> Type)

Defined in Data.Parameterized.Classes

Methods

eqF :: Const a a0 -> Const a a0 -> Bool

class PolyEq u v where

A polymorphic equality operator that generalizes TestEquality.

Minimal complete definition

polyEqF

Methods

polyEqF :: u -> v -> Maybe (u :~: v)

polyEq :: u -> v -> Bool

Instances

PolyEq (NatRepr m) (NatRepr n)

Defined in Data.Parameterized.NatRepr.Internal

Methods

polyEqF :: NatRepr m -> NatRepr n -> Maybe (NatRepr m :~: NatRepr n)

polyEq :: NatRepr m -> NatRepr n -> Bool

PolyEq (BoolRepr m) (BoolRepr n)

Defined in Data.Parameterized.BoolRepr

Methods

polyEqF :: BoolRepr m -> BoolRepr n -> Maybe (BoolRepr m :~: BoolRepr n)

polyEq :: BoolRepr m -> BoolRepr n -> Bool

PolyEq (PeanoRepr m) (PeanoRepr n)

Defined in Data.Parameterized.Peano

Methods

polyEqF :: PeanoRepr m -> PeanoRepr n -> Maybe (PeanoRepr m :~: PeanoRepr n)

polyEq :: PeanoRepr m -> PeanoRepr n -> Bool

TestEquality f => PolyEq (Assignment f x) (Assignment f y)

Defined in Data.Parameterized.Context.Safe

Methods

polyEqF :: Assignment f x -> Assignment f y -> Maybe (Assignment f x :~: Assignment f y)

polyEq :: Assignment f x -> Assignment f y -> Bool

Ordering generalization

class TestEquality ktp => OrdF (ktp :: k -> *) where

A parameterized type that can be compared on distinct instances.

Minimal complete definition

compareF

Methods

compareF :: ktp x -> ktp y -> OrderingF x y

compareF compares two keys with different type parameters. Instances must ensure that keys are only equal if the type parameters are equal.

leqF :: ktp x -> ktp y -> Bool

ltF :: ktp x -> ktp y -> Bool

geqF :: ktp x -> ktp y -> Bool

gtF :: ktp x -> ktp y -> Bool

Instances

OrdF BoolRepr

Defined in Data.Parameterized.BoolRepr

Methods

compareF :: BoolRepr x -> BoolRepr y -> OrderingF x y

leqF :: BoolRepr x -> BoolRepr y -> Bool

ltF :: BoolRepr x -> BoolRepr y -> Bool

geqF :: BoolRepr x -> BoolRepr y -> Bool

gtF :: BoolRepr x -> BoolRepr y -> Bool

OrdF NatRepr

Defined in Data.Parameterized.NatRepr.Internal

Methods

compareF :: NatRepr x -> NatRepr y -> OrderingF x y

leqF :: NatRepr x -> NatRepr y -> Bool

ltF :: NatRepr x -> NatRepr y -> Bool

geqF :: NatRepr x -> NatRepr y -> Bool

gtF :: NatRepr x -> NatRepr y -> Bool

OrdF SymbolRepr

Defined in Data.Parameterized.SymbolRepr

Methods

compareF :: SymbolRepr x -> SymbolRepr y -> OrderingF x y

leqF :: SymbolRepr x -> SymbolRepr y -> Bool

ltF :: SymbolRepr x -> SymbolRepr y -> Bool

geqF :: SymbolRepr x -> SymbolRepr y -> Bool

gtF :: SymbolRepr x -> SymbolRepr y -> Bool

OrdF PeanoRepr

Defined in Data.Parameterized.Peano

Methods

compareF :: PeanoRepr x -> PeanoRepr y -> OrderingF x y

leqF :: PeanoRepr x -> PeanoRepr y -> Bool

ltF :: PeanoRepr x -> PeanoRepr y -> Bool

geqF :: PeanoRepr x -> PeanoRepr y -> Bool

gtF :: PeanoRepr x -> PeanoRepr y -> Bool

OrdF (Nonce :: k -> Type)

Defined in Data.Parameterized.Nonce.Unsafe

Methods

compareF :: Nonce x -> Nonce y -> OrderingF x y

leqF :: Nonce x -> Nonce y -> Bool

ltF :: Nonce x -> Nonce y -> Bool

geqF :: Nonce x -> Nonce y -> Bool

gtF :: Nonce x -> Nonce y -> Bool

OrdF (Nonce s :: k -> Type)

Defined in Data.Parameterized.Nonce

Methods

compareF :: Nonce s x -> Nonce s y -> OrderingF x y

leqF :: Nonce s x -> Nonce s y -> Bool

ltF :: Nonce s x -> Nonce s y -> Bool

geqF :: Nonce s x -> Nonce s y -> Bool

gtF :: Nonce s x -> Nonce s y -> Bool

OrdF (Index l :: k -> Type)

Defined in Data.Parameterized.List

Methods

compareF :: Index l x -> Index l y -> OrderingF x y

leqF :: Index l x -> Index l y -> Bool

ltF :: Index l x -> Index l y -> Bool

geqF :: Index l x -> Index l y -> Bool

gtF :: Index l x -> Index l y -> Bool

OrdF (Index ctx :: k -> Type)

Defined in Data.Parameterized.Context.Unsafe

Methods

compareF :: Index ctx x -> Index ctx y -> OrderingF x y

leqF :: Index ctx x -> Index ctx y -> Bool

ltF :: Index ctx x -> Index ctx y -> Bool

geqF :: Index ctx x -> Index ctx y -> Bool

gtF :: Index ctx x -> Index ctx y -> Bool

OrdF (Index ctx :: k -> Type)

Defined in Data.Parameterized.Context.Safe

Methods

compareF :: Index ctx x -> Index ctx y -> OrderingF x y

leqF :: Index ctx x -> Index ctx y -> Bool

ltF :: Index ctx x -> Index ctx y -> Bool

geqF :: Index ctx x -> Index ctx y -> Bool

gtF :: Index ctx x -> Index ctx y -> Bool

OrdF f => OrdF (Compose f g :: k1 -> Type)

Defined in Data.Parameterized.Classes

Methods

compareF :: Compose f g x -> Compose f g y -> OrderingF x y

leqF :: Compose f g x -> Compose f g y -> Bool

ltF :: Compose f g x -> Compose f g y -> Bool

geqF :: Compose f g x -> Compose f g y -> Bool

gtF :: Compose f g x -> Compose f g y -> Bool

OrdF f => OrdF (List f :: [k] -> Type)

Defined in Data.Parameterized.List

Methods

compareF :: List f x -> List f y -> OrderingF x y

leqF :: List f x -> List f y -> Bool

ltF :: List f x -> List f y -> Bool

geqF :: List f x -> List f y -> Bool

gtF :: List f x -> List f y -> Bool

OrdF f => OrdF (Assignment f :: Ctx k -> Type)

Defined in Data.Parameterized.Context.Unsafe

Methods

compareF :: Assignment f x -> Assignment f y -> OrderingF x y

leqF :: Assignment f x -> Assignment f y -> Bool

ltF :: Assignment f x -> Assignment f y -> Bool

geqF :: Assignment f x -> Assignment f y -> Bool

gtF :: Assignment f x -> Assignment f y -> Bool

OrdF f => OrdF (Assignment f :: Ctx k -> Type)

Defined in Data.Parameterized.Context.Safe

Methods

compareF :: Assignment f x -> Assignment f y -> OrderingF x y

leqF :: Assignment f x -> Assignment f y -> Bool

ltF :: Assignment f x -> Assignment f y -> Bool

geqF :: Assignment f x -> Assignment f y -> Bool

gtF :: Assignment f x -> Assignment f y -> Bool

lexCompareF :: forall (f :: j -> *) (a :: j) (b :: j) (c :: k) (d :: k). OrdF f => f a -> f b -> (a ~ b => OrderingF c d) -> OrderingF c d

Compare two values, and if they are equal compare the next values, otherwise return LTF or GTF

data OrderingF x y where

Ordering over two distinct types with a proof they are equal.

Constructors

LTF :: OrderingF x y

EQF :: OrderingF x x

GTF :: OrderingF x y

joinOrderingF :: forall (a :: j) (b :: j) (c :: k) (d :: k). OrderingF a b -> (a ~ b => OrderingF c d) -> OrderingF c d

joinOrderingF x y first compares on x, returning an equivalent value if it is not EQF. If it is EQF, it returns y.

orderingF_refl :: OrderingF x y -> Maybe (x :~: y)

toOrdering :: OrderingF x y -> Ordering

Convert OrderingF to standard ordering.

fromOrdering :: Ordering -> OrderingF x x

Convert standard ordering to OrderingF.

ordFCompose :: forall (f :: k -> *) (g :: l -> k) x y. (forall w z. f w -> f z -> OrderingF w z) -> Compose f g x -> Compose f g y -> OrderingF x y

If the "outer" functor has an OrdF instance, then one can be generated for the "inner" functor. The type-level evidence of equality is deduced via generativity of g, e.g. the inference g x ~ g y implies x ~ y.

Typeclass generalizations

class ShowF (f :: k -> *) where

A parameterized type that can be shown on all instances.

To implement ShowF g, one should implement an instance Show (g tp) for all argument types tp, then write an empty instance instance ShowF g.

Minimal complete definition

Nothing

Methods

withShow :: p f -> q tp -> (Show (f tp) => a) -> a

Provides a show instance for each type.

withShow :: Show (f tp) => p f -> q tp -> (Show (f tp) => a) -> a

Provides a show instance for each type.

showF :: forall tp. f tp -> String

showsPrecF :: forall tp. Int -> f tp -> String -> String

Like showsPrec, the precedence argument is one more than the precedence of the enclosing context.

Instances

ShowF BoolRepr

Defined in Data.Parameterized.BoolRepr

Methods

withShow :: p BoolRepr -> q tp -> (Show (BoolRepr tp) -> a) -> a

showF :: BoolRepr tp -> String

showsPrecF :: Int -> BoolRepr tp -> String -> String

ShowF NatRepr

Defined in Data.Parameterized.NatRepr.Internal

Methods

withShow :: p NatRepr -> q tp -> (Show (NatRepr tp) -> a) -> a

showF :: NatRepr tp -> String

showsPrecF :: Int -> NatRepr tp -> String -> String

ShowF SymbolRepr

Defined in Data.Parameterized.SymbolRepr

Methods

withShow :: p SymbolRepr -> q tp -> (Show (SymbolRepr tp) -> a) -> a

showF :: SymbolRepr tp -> String

showsPrecF :: Int -> SymbolRepr tp -> String -> String

ShowF PeanoRepr

Defined in Data.Parameterized.Peano

Methods

withShow :: p PeanoRepr -> q tp -> (Show (PeanoRepr tp) -> a) -> a

showF :: PeanoRepr tp -> String

showsPrecF :: Int -> PeanoRepr tp -> String -> String

ShowF (Nonce :: k -> Type)

Defined in Data.Parameterized.Nonce.Unsafe

Methods

withShow :: p Nonce -> q tp -> (Show (Nonce tp) -> a) -> a

showF :: Nonce tp -> String

showsPrecF :: Int -> Nonce tp -> String -> String

Show x => ShowF (Const x :: k -> Type)

Defined in Data.Parameterized.Classes

Methods

withShow :: p (Const x) -> q tp -> (Show (Const x tp) -> a) -> a

showF :: Const x tp -> String

showsPrecF :: Int -> Const x tp -> String -> String

ShowF (Nonce s :: k -> Type)

Defined in Data.Parameterized.Nonce

Methods

withShow :: p (Nonce s) -> q tp -> (Show (Nonce s tp) -> a) -> a

showF :: Nonce s tp -> String

showsPrecF :: Int -> Nonce s tp -> String -> String

ShowF (Index l :: k -> Type)

Defined in Data.Parameterized.List

Methods

withShow :: p (Index l) -> q tp -> (Show (Index l tp) -> a) -> a

showF :: Index l tp -> String

showsPrecF :: Int -> Index l tp -> String -> String

ShowF (Index ctx :: k -> Type)

Defined in Data.Parameterized.Context.Unsafe

Methods

withShow :: p (Index ctx) -> q tp -> (Show (Index ctx tp) -> a) -> a

showF :: Index ctx tp -> String

showsPrecF :: Int -> Index ctx tp -> String -> String

ShowF (Index ctx :: k -> Type)

Defined in Data.Parameterized.Context.Safe

Methods

withShow :: p (Index ctx) -> q tp -> (Show (Index ctx tp) -> a) -> a

showF :: Index ctx tp -> String

showsPrecF :: Int -> Index ctx tp -> String -> String

ShowF f => ShowF (List f :: [k] -> Type)

Defined in Data.Parameterized.List

Methods

withShow :: p (List f) -> q tp -> (Show (List f tp) -> a) -> a

showF :: List f tp -> String

showsPrecF :: Int -> List f tp -> String -> String

ShowF f => ShowF (Assignment f :: Ctx k -> Type)

Defined in Data.Parameterized.Context.Unsafe

Methods

withShow :: p (Assignment f) -> q tp -> (Show (Assignment f tp) -> a) -> a

showF :: Assignment f tp -> String

showsPrecF :: Int -> Assignment f tp -> String -> String

ShowF f => ShowF (Assignment f :: Ctx k -> Type)

Defined in Data.Parameterized.Context.Safe

Methods

withShow :: p (Assignment f) -> q tp -> (Show (Assignment f tp) -> a) -> a

showF :: Assignment f tp -> String

showsPrecF :: Int -> Assignment f tp -> String -> String

showsF :: ShowF f => f tp -> String -> String

class HashableF (f :: k -> *) where

A parameterized type that is hashable on all instances.

Minimal complete definition

hashWithSaltF

Methods

hashWithSaltF :: Int -> f tp -> Int

hashF :: f tp -> Int

Hash with default salt.

Instances

HashableF BoolRepr

Defined in Data.Parameterized.BoolRepr

Methods

hashWithSaltF :: Int -> BoolRepr tp -> Int

hashF :: BoolRepr tp -> Int

HashableF NatRepr

Defined in Data.Parameterized.NatRepr.Internal

Methods

hashWithSaltF :: Int -> NatRepr tp -> Int

hashF :: NatRepr tp -> Int

HashableF SymbolRepr

Defined in Data.Parameterized.SymbolRepr

Methods

hashWithSaltF :: Int -> SymbolRepr tp -> Int

hashF :: SymbolRepr tp -> Int

HashableF PeanoRepr

Defined in Data.Parameterized.Peano

Methods

hashWithSaltF :: Int -> PeanoRepr tp -> Int

hashF :: PeanoRepr tp -> Int

HashableF (Nonce :: k -> Type)

Defined in Data.Parameterized.Nonce.Unsafe

Methods

hashWithSaltF :: Int -> Nonce tp -> Int

hashF :: Nonce tp -> Int

Hashable a => HashableF (Const a :: k -> Type)

Defined in Data.Parameterized.Classes

Methods

hashWithSaltF :: Int -> Const a tp -> Int

hashF :: Const a tp -> Int

HashableF (Nonce s :: k -> Type)

Defined in Data.Parameterized.Nonce

Methods

hashWithSaltF :: Int -> Nonce s tp -> Int

hashF :: Nonce s tp -> Int

HashableF (Index ctx :: k -> Type)

Defined in Data.Parameterized.Context.Unsafe

Methods

hashWithSaltF :: Int -> Index ctx tp -> Int

hashF :: Index ctx tp -> Int

HashableF (Index ctx :: k -> Type)

Defined in Data.Parameterized.Context.Safe

Methods

hashWithSaltF :: Int -> Index ctx tp -> Int

hashF :: Index ctx tp -> Int

HashableF f => HashableF (Assignment f :: Ctx k -> Type)

Defined in Data.Parameterized.Context.Unsafe

Methods

hashWithSaltF :: Int -> Assignment f tp -> Int

hashF :: Assignment f tp -> Int

HashableF f => HashableF (Assignment f :: Ctx k -> Type)

Defined in Data.Parameterized.Context.Safe

Methods

hashWithSaltF :: Int -> Assignment f tp -> Int

hashF :: Assignment f tp -> Int

class CoercibleF (rtp :: k -> *) where

An instance of CoercibleF gives a way to coerce between all the types of a family. We generally use this to witness the fact that the type parameter to rtp is a phantom type by giving an implementation in terms of Data.Coerce.coerce.

Methods

coerceF :: rtp a -> rtp b

Instances

CoercibleF (Const x :: k -> Type)

Defined in Data.Parameterized.Classes

Methods

coerceF :: Const x a -> Const x b

Optics generalizations

type family IndexF (m :: *) :: k -> *

Instances

type IndexF (Assignment f ctx)

Defined in Data.Parameterized.Context.Unsafe

type IndexF (Assignment f ctx) = Index ctx

type IndexF (Assignment f ctx)

Defined in Data.Parameterized.Context.Safe

type IndexF (Assignment f ctx) = Index ctx

type IndexF (MapF k2 v)

Defined in Data.Parameterized.Map

type IndexF (MapF k2 v) = k2

type family IxValueF (m :: *) :: k -> *

Instances

type IxValueF (Assignment f ctx)

Defined in Data.Parameterized.Context.Unsafe

type IxValueF (Assignment f ctx) = f

type IxValueF (Assignment f ctx)

Defined in Data.Parameterized.Context.Safe

type IxValueF (Assignment f ctx) = f

type IxValueF (MapF k2 v)

Defined in Data.Parameterized.Map

type IxValueF (MapF k2 v) = v

class IxedF k m where

Parameterized generalization of the lens Ixed class.

Methods

ixF :: forall (x :: k). IndexF m x -> Traversal' m (IxValueF m x)

Given an index into a container, build a traversal that visits the given element in the container, if it exists.

Instances

IxedF k (Assignment f ctx)

Defined in Data.Parameterized.Context.Unsafe

Methods

ixF :: IndexF (Assignment f ctx) x -> Traversal' (Assignment f ctx) (IxValueF (Assignment f ctx) x)

IxedF k (Assignment f ctx)

Defined in Data.Parameterized.Context.Safe

Methods

ixF :: IndexF (Assignment f ctx) x -> Traversal' (Assignment f ctx) (IxValueF (Assignment f ctx) x)

OrdF k => IxedF a (MapF k v)

Turn a map key into a traversal that visits the indicated element in the map, if it exists.

Defined in Data.Parameterized.Map

Methods

ixF :: IndexF (MapF k v) x -> Traversal' (MapF k v) (IxValueF (MapF k v) x)

class IxedF k m => IxedF' k m where

Parameterized generalization of the lens Ixed class, but with the guarantee that indexes exist in the container.

Methods

ixF' :: forall (x :: k). IndexF m x -> Lens' m (IxValueF m x)

Given an index into a container, build a lens that points into the given element in the container.

Instances

IxedF' k (Assignment f ctx)

Defined in Data.Parameterized.Context.Unsafe

Methods

ixF' :: IndexF (Assignment f ctx) x -> Lens' (Assignment f ctx) (IxValueF (Assignment f ctx) x)

IxedF' k (Assignment f ctx)

Defined in Data.Parameterized.Context.Safe

Methods

ixF' :: IndexF (Assignment f ctx) x -> Lens' (Assignment f ctx) (IxValueF (Assignment f ctx) x)

class IxedF k m => AtF k m where

Parameterized generalization of the lens At class.

Methods

atF :: forall (x :: k). IndexF m x -> Lens' m (Maybe (IxValueF m x))

Given an index into a container, build a lens that points into the given position in the container, whether or not it currently exists. Setting values of atF to a Just value will insert the value if it does not already exist.

Instances

OrdF k => AtF a (MapF k v)

Turn a map key into a lens that points into the indicated position in the map.

Defined in Data.Parameterized.Map

Methods

atF :: IndexF (MapF k v) x -> Lens' (MapF k v) (Maybe (IxValueF (MapF k v) x))

KnownRepr

class KnownRepr (f :: k -> *) (ctx :: k) where

This class is parameterized by a kind k (typically a data kind), a type constructor f of kind k -> * (typically a GADT of singleton types indexed by k), and an index parameter ctx of kind k.

Methods

knownRepr :: f ctx

Instances

KnownRepr BoolRepr False

Defined in Data.Parameterized.BoolRepr

Methods

knownRepr :: BoolRepr False

KnownRepr BoolRepr True

Defined in Data.Parameterized.BoolRepr

Methods

knownRepr :: BoolRepr True

KnownNat n => KnownRepr NatRepr (n :: Nat)

Defined in Data.Parameterized.NatRepr.Internal

Methods

knownRepr :: NatRepr n

KnownSymbol s => KnownRepr SymbolRepr (s :: Symbol)

Defined in Data.Parameterized.SymbolRepr

Methods

knownRepr :: SymbolRepr s

KnownRepr PeanoRepr Z

Defined in Data.Parameterized.Peano

Methods

knownRepr :: PeanoRepr Z

KnownRepr PeanoRepr n => KnownRepr PeanoRepr (S n :: Peano)

Defined in Data.Parameterized.Peano

Methods

knownRepr :: PeanoRepr (S n)

KnownRepr (List f :: [k] -> Type) ([] :: [k])

Defined in Data.Parameterized.List

Methods

knownRepr :: List f []

KnownRepr (Assignment f :: Ctx k -> Type) (EmptyCtx :: Ctx k)

Defined in Data.Parameterized.Context.Unsafe

Methods

knownRepr :: Assignment f EmptyCtx

KnownRepr (Assignment f :: Ctx k -> Type) (EmptyCtx :: Ctx k)

Defined in Data.Parameterized.Context.Safe

Methods

knownRepr :: Assignment f EmptyCtx

(KnownRepr f s, KnownRepr (List f) sh) => KnownRepr (List f :: [a] -> Type) (s ': sh :: [a])

Defined in Data.Parameterized.List

Methods

knownRepr :: List f (s ': sh)

(KnownRepr (Assignment f) ctx, KnownRepr f bt) => KnownRepr (Assignment f :: Ctx k -> Type) (ctx ::> bt :: Ctx k)

Defined in Data.Parameterized.Context.Unsafe

Methods

knownRepr :: Assignment f (ctx ::> bt)

(KnownRepr (Assignment f) ctx, KnownRepr f bt) => KnownRepr (Assignment f :: Ctx k -> Type) (ctx ::> bt :: Ctx k)

Defined in Data.Parameterized.Context.Safe

Methods

knownRepr :: Assignment f (ctx ::> bt)

Re-exports

isJust :: Maybe a -> Bool

The isJust function returns True iff its argument is of the form Just _.

Examples

Basic usage:

>>> isJust (Just 3)
True

>>> isJust (Just ())
True

>>> isJust Nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (Just Nothing)
True