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 -> *) 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.

Minimal complete definition

testEquality

Methods

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

Conditionally prove the equality of a and b.

Instances

TestEquality NatRepr

Defined in Data.Parameterized.NatRepr

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 (Nonce :: k -> *)

Defined in Data.Parameterized.Nonce.Unsafe

Methods

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

TestEquality (TypeRep :: k -> *)

Defined in Data.Typeable.Internal

Methods

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

TestEquality (Nonce s :: k -> *)

Defined in Data.Parameterized.Nonce

Methods

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

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

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

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

TestEquality (Index l :: k -> *)

Defined in Data.Parameterized.List

Methods

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

TestEquality (Index ctx :: k -> *)

Defined in Data.Parameterized.Context.Unsafe

Methods

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

TestEquality (Index ctx :: k -> *)

Defined in Data.Parameterized.Context.Safe

Methods

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

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

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

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

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

Defined in Data.Parameterized.List

Methods

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

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

Defined in Data.Parameterized.Context.Unsafe

Methods

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

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

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 -> * 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 :: a :~: a

Instances

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

Since: base-4.7.0.0

Defined in Control.Category

Methods

id :: a :~: a

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

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

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

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

NFData2 ((:~:) :: * -> * -> *)

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)

Defined in Data.Type.Equality

Methods

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

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

Ord (a :~: b)

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)

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.

Minimal complete definition

eqF

Methods

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

Instances

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

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

Methods

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

polyEq :: NatRepr m -> NatRepr 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 NatRepr

Defined in Data.Parameterized.NatRepr

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 (Nonce :: k -> *)

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 -> *)

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 -> *)

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 -> *)

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 -> *)

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 (List f :: [k] -> *)

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 -> *)

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 -> *)

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.

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.

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 NatRepr

Defined in Data.Parameterized.NatRepr

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 (Nonce :: k -> *)

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 -> *)

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 -> *)

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 -> *)

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 -> *)

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 -> *)

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] -> *)

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 -> *)

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 -> *)

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 NatRepr

Defined in Data.Parameterized.NatRepr

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 (Nonce :: k -> *)

Defined in Data.Parameterized.Nonce.Unsafe

Methods

hashWithSaltF :: Int -> Nonce tp -> Int

hashF :: Nonce tp -> Int

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

Defined in Data.Parameterized.Classes

Methods

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

hashF :: Const a tp -> Int

HashableF (Nonce s :: k -> *)

Defined in Data.Parameterized.Nonce

Methods

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

hashF :: Nonce s tp -> Int

HashableF (Index ctx :: k -> *)

Defined in Data.Parameterized.Context.Unsafe

Methods

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

hashF :: Index ctx tp -> Int

HashableF (Index ctx :: k -> *)

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 -> *)

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 -> *)

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.

Minimal complete definition

coerceF

Methods

coerceF :: rtp a -> rtp b

Instances

CoercibleF (Const x :: k -> *)

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.

Minimal complete definition

ixF

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.

Minimal complete definition

ixF'

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.

Minimal complete definition

atF

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.

Minimal complete definition

knownRepr

Methods

knownRepr :: f ctx

Instances

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

Defined in Data.Parameterized.NatRepr

Methods

knownRepr :: NatRepr n

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

Defined in Data.Parameterized.SymbolRepr

Methods

knownRepr :: SymbolRepr s

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

Defined in Data.Parameterized.List

Methods

knownRepr :: List f []

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

Defined in Data.Parameterized.Context.Unsafe

Methods

knownRepr :: Assignment f EmptyCtx

KnownRepr (Assignment f :: Ctx k -> *) (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] -> *) (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 -> *) (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 -> *) (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