Copyright	(c) Galois Inc 2014-2019
Maintainer	Joe Hendrix <jhendrix@galois.com>
Safe Haskell	Safe
Language	Haskell2010

Data.Parameterized.Classes

Contents

Equality exports
Ordering generalization
Typeclass generalizations
Type function application constructor
Optics generalizations
KnownRepr
Re-exports

Description

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

Synopsis

class TestEquality (f :: k -> Type) where
- testEquality :: forall (a :: k) (b :: k). f a -> f b -> Maybe (a :~: b)
data (a :: k) :~: (b :: k) where
- Refl :: forall k (a :: k). a :~: a
class EqF (f :: k -> Type) where
- eqF :: f a -> f a -> Bool
class PolyEq u v where
- polyEqF :: u -> v -> Maybe (u :~: v)
- polyEq :: u -> v -> Bool
class TestEquality ktp => OrdF (ktp :: k -> Type) where
- compareF :: ktp x -> ktp y -> OrderingF x y
- leqF :: ktp x -> ktp y -> Bool
- ltF :: ktp x -> ktp y -> Bool
- geqF :: ktp x -> ktp y -> Bool
- gtF :: ktp x -> ktp y -> Bool
lexCompareF :: forall j k (f :: j -> Type) (a :: j) (b :: j) (c :: k) (d :: k). OrdF f => f a -> f b -> (a ~ b => OrderingF c d) -> OrderingF c d
data OrderingF x y where
- LTF :: OrderingF x y
- EQF :: OrderingF x x
- GTF :: OrderingF x y
joinOrderingF :: forall j k (a :: j) (b :: j) (c :: k) (d :: k). OrderingF a b -> (a ~ b => OrderingF c d) -> OrderingF c d
orderingF_refl :: OrderingF x y -> Maybe (x :~: y)
toOrdering :: OrderingF x y -> Ordering
fromOrdering :: Ordering -> OrderingF x x
ordFCompose :: forall k l (f :: k -> Type) (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
class ShowF (f :: k -> Type) where
- withShow :: p f -> q tp -> (Show (f tp) => a) -> a
- showF :: forall tp. f tp -> String
- showsPrecF :: forall tp. Int -> f tp -> String -> String
showsF :: ShowF f => f tp -> String -> String
class HashableF (f :: k -> Type) where
- hashWithSaltF :: Int -> f tp -> Int
- hashF :: f tp -> Int
class CoercibleF (rtp :: k -> Type) where
- coerceF :: rtp a -> rtp b
newtype TypeAp (f :: k -> Type) (tp :: k) = TypeAp (f tp)
type family IndexF (m :: Type) :: k -> Type
type family IxValueF (m :: Type) :: k -> Type
class IxedF k m where
- ixF :: forall (x :: k). IndexF m x -> Traversal' m (IxValueF m x)
class IxedF k m => IxedF' k m where
- ixF' :: forall (x :: k). IndexF m x -> Lens' m (IxValueF m x)
class IxedF k m => AtF k m where
- atF :: forall (x :: k). IndexF m x -> Lens' m (Maybe (IxValueF m x))
class KnownRepr (f :: k -> Type) (ctx :: k) where
- knownRepr :: f ctx
class Hashable a where
- hashWithSalt :: Int -> a -> Int
- hash :: a -> Int
isJust :: Maybe a -> Bool

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 :: forall (a :: k) (b :: k). f a -> f b -> Maybe (a :~: b) #

Conditionally prove the equality of a and b.

Instances

Instances details

TestEquality BoolRepr Source #
Instance details Defined in Data.Parameterized.BoolRepr Methods testEquality :: forall (a :: k) (b :: k). BoolRepr a -> BoolRepr b -> Maybe (a :~: b) #
TestEquality NatRepr Source #
Instance details Defined in Data.Parameterized.NatRepr.Internal Methods testEquality :: forall (a :: k) (b :: k). NatRepr a -> NatRepr b -> Maybe (a :~: b) #
TestEquality SymbolRepr Source #
Instance details Defined in Data.Parameterized.SymbolRepr Methods testEquality :: forall (a :: k) (b :: k). SymbolRepr a -> SymbolRepr b -> Maybe (a :~: b) #
TestEquality PeanoRepr Source #
Instance details Defined in Data.Parameterized.Peano Methods testEquality :: forall (a :: k) (b :: k). PeanoRepr a -> PeanoRepr b -> Maybe (a :~: b) #
TestEquality (Nonce :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Nonce.Unsafe Methods testEquality :: forall (a :: k0) (b :: k0). Nonce a -> Nonce b -> Maybe (a :~: b) #
TestEquality (TypeRep :: k -> Type)
Instance details Defined in Data.Typeable.Internal Methods testEquality :: forall (a :: k0) (b :: k0). TypeRep a -> TypeRep b -> Maybe (a :~: b) #
TestEquality (Nonce s :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Nonce Methods testEquality :: forall (a :: k0) (b :: k0). Nonce s a -> Nonce s b -> Maybe (a :~: b) #
TestEquality ((:~:) a :: k -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods testEquality :: forall (a0 :: k0) (b :: k0). (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b) #
TestEquality (Index l :: k -> Type) Source #
Instance details Defined in Data.Parameterized.List Methods testEquality :: forall (a :: k0) (b :: k0). Index l a -> Index l b -> Maybe (a :~: b) #
TestEquality (Index ctx :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods testEquality :: forall (a :: k0) (b :: k0). Index ctx a -> Index ctx b -> Maybe (a :~: b) #
TestEquality ((:~~:) a :: k -> Type)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods testEquality :: forall (a0 :: k0) (b :: k0). (a :~~: a0) -> (a :~~: b) -> Maybe (a0 :~: b) #
TestEquality f => TestEquality (Compose f g :: k2 -> Type)	The deduction (via generativity) that if `g x :~: g y` then `x :~: y`. Since: base-4.14.0.0
Instance details Defined in Data.Functor.Compose Methods testEquality :: forall (a :: k) (b :: k). Compose f g a -> Compose f g b -> Maybe (a :~: b) #
TestEquality f => TestEquality (List f :: [k] -> Type) Source #
Instance details Defined in Data.Parameterized.List Methods testEquality :: forall (a :: k0) (b :: k0). List f a -> List f b -> Maybe (a :~: b) #
TestEquality f => TestEquality (Assignment f :: Ctx k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods testEquality :: forall (a :: k0) (b :: k0). Assignment f a -> Assignment f b -> Maybe (a :~: b) #
(TestEquality f, TestEquality g) => TestEquality (PairRepr f g :: (k1, k2) -> Type) Source #
Instance details Defined in Data.Parameterized.DataKind Methods testEquality :: forall (a :: k) (b :: k). PairRepr f g a -> PairRepr f g b -> Maybe (a :~: b) #

data (a :: k) :~: (b :: 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 :: forall k (a :: k). a :~: a

Instances

Instances details

Category ((:~:) :: k -> k -> Type)	Since: base-4.7.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). a :~: a # (.) :: forall (b :: k0) (c :: k0) (a :: k0). (b :~: c) -> (a :~: b) -> a :~: c #
TestEquality ((:~:) a :: k -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods testEquality :: forall (a0 :: k0) (b :: k0). (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b) #
NFData2 ((:~:) :: Type -> Type -> Type)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> (a :~: b) -> () #
NFData1 ((:~:) a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> (a :~: a0) -> () #
a ~ b => Bounded (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~: b # maxBound :: a :~: b #
a ~ b => Enum (a :~: b)	Since: base-4.7.0.0
Instance details 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
Instance details 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
Instance details 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 :: forall r r'. (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
Instance details 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
Instance details 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
Instance details 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
Instance details Defined in Control.DeepSeq Methods rnf :: (a :~: b) -> () #
HasDict (a ~ b) (a :~: b)
Instance details Defined in Data.Constraint Methods evidence :: (a :~: b) -> Dict (a ~ b) #

class EqF (f :: k -> Type) where Source #

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 Source #

Instances

Instances details

Eq a => EqF (Const a :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Classes Methods eqF :: forall (a0 :: k0). Const a a0 -> Const a a0 -> Bool Source #

class PolyEq u v where Source #

A polymorphic equality operator that generalizes TestEquality.

Minimal complete definition

polyEqF

Methods

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

polyEq :: u -> v -> Bool Source #

Instances

Instances details

PolyEq (NatRepr m) (NatRepr n) Source #
Instance details Defined in Data.Parameterized.NatRepr.Internal Methods polyEqF :: NatRepr m -> NatRepr n -> Maybe (NatRepr m :~: NatRepr n) Source # polyEq :: NatRepr m -> NatRepr n -> Bool Source #
PolyEq (BoolRepr m) (BoolRepr n) Source #
Instance details Defined in Data.Parameterized.BoolRepr Methods polyEqF :: BoolRepr m -> BoolRepr n -> Maybe (BoolRepr m :~: BoolRepr n) Source # polyEq :: BoolRepr m -> BoolRepr n -> Bool Source #
PolyEq (PeanoRepr m) (PeanoRepr n) Source #
Instance details Defined in Data.Parameterized.Peano Methods polyEqF :: PeanoRepr m -> PeanoRepr n -> Maybe (PeanoRepr m :~: PeanoRepr n) Source # polyEq :: PeanoRepr m -> PeanoRepr n -> Bool Source #

Ordering generalization

class TestEquality ktp => OrdF (ktp :: k -> Type) where Source #

The OrdF class is a total ordering over parameterized types so that types with different parameters can be compared.

Instances of OrdF are expected to satisfy the following laws:

Transitivity: if leqF x y && leqF y z = True, then leqF x = z = True
Reflexivity: leqF x x = True
Antisymmetry: if leqF x y && leqF y x = True, then testEquality x y = Just Refl

Note that the following operator interactions are expected to hold:

geqF x y iff leqF y x
ltF x y iff leqF x y && testEquality x y = Nothing
gtF x y iff ltF y x
ltF x y iff compareF x y == LTF
gtF x y iff compareF x y == GTF
isJust (testEquality x y) iff compareF x y == EQF

Furthermore, when x and y both have type (k tp), we expect:

compareF x y == EQF equals compare x y when Ord (k tp) has an instance.
isJust (testEquality x y) equals x == y when Eq (k tp) has an instance.

Minimal complete definition: either compareF or leqF. Using compareF can be more efficient for complex types.

Minimal complete definition

compareF | leqF

Methods

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

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

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

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

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

Instances

Instances details

OrdF BoolRepr Source #
Instance details Defined in Data.Parameterized.BoolRepr Methods compareF :: forall (x :: k) (y :: k). BoolRepr x -> BoolRepr y -> OrderingF x y Source # leqF :: forall (x :: k) (y :: k). BoolRepr x -> BoolRepr y -> Bool Source # ltF :: forall (x :: k) (y :: k). BoolRepr x -> BoolRepr y -> Bool Source # geqF :: forall (x :: k) (y :: k). BoolRepr x -> BoolRepr y -> Bool Source # gtF :: forall (x :: k) (y :: k). BoolRepr x -> BoolRepr y -> Bool Source #
OrdF NatRepr Source #
Instance details Defined in Data.Parameterized.NatRepr.Internal Methods compareF :: forall (x :: k) (y :: k). NatRepr x -> NatRepr y -> OrderingF x y Source # leqF :: forall (x :: k) (y :: k). NatRepr x -> NatRepr y -> Bool Source # ltF :: forall (x :: k) (y :: k). NatRepr x -> NatRepr y -> Bool Source # geqF :: forall (x :: k) (y :: k). NatRepr x -> NatRepr y -> Bool Source # gtF :: forall (x :: k) (y :: k). NatRepr x -> NatRepr y -> Bool Source #
OrdF SymbolRepr Source #
Instance details Defined in Data.Parameterized.SymbolRepr Methods compareF :: forall (x :: k) (y :: k). SymbolRepr x -> SymbolRepr y -> OrderingF x y Source # leqF :: forall (x :: k) (y :: k). SymbolRepr x -> SymbolRepr y -> Bool Source # ltF :: forall (x :: k) (y :: k). SymbolRepr x -> SymbolRepr y -> Bool Source # geqF :: forall (x :: k) (y :: k). SymbolRepr x -> SymbolRepr y -> Bool Source # gtF :: forall (x :: k) (y :: k). SymbolRepr x -> SymbolRepr y -> Bool Source #
OrdF PeanoRepr Source #
Instance details Defined in Data.Parameterized.Peano Methods compareF :: forall (x :: k) (y :: k). PeanoRepr x -> PeanoRepr y -> OrderingF x y Source # leqF :: forall (x :: k) (y :: k). PeanoRepr x -> PeanoRepr y -> Bool Source # ltF :: forall (x :: k) (y :: k). PeanoRepr x -> PeanoRepr y -> Bool Source # geqF :: forall (x :: k) (y :: k). PeanoRepr x -> PeanoRepr y -> Bool Source # gtF :: forall (x :: k) (y :: k). PeanoRepr x -> PeanoRepr y -> Bool Source #
OrdF (Nonce :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Nonce.Unsafe Methods compareF :: forall (x :: k0) (y :: k0). Nonce x -> Nonce y -> OrderingF x y Source # leqF :: forall (x :: k0) (y :: k0). Nonce x -> Nonce y -> Bool Source # ltF :: forall (x :: k0) (y :: k0). Nonce x -> Nonce y -> Bool Source # geqF :: forall (x :: k0) (y :: k0). Nonce x -> Nonce y -> Bool Source # gtF :: forall (x :: k0) (y :: k0). Nonce x -> Nonce y -> Bool Source #
OrdF (Nonce s :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Nonce Methods compareF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> OrderingF x y Source # leqF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> Bool Source # ltF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> Bool Source # geqF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> Bool Source # gtF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> Bool Source #
OrdF (Index l :: k -> Type) Source #
Instance details Defined in Data.Parameterized.List Methods compareF :: forall (x :: k0) (y :: k0). Index l x -> Index l y -> OrderingF x y Source # leqF :: forall (x :: k0) (y :: k0). Index l x -> Index l y -> Bool Source # ltF :: forall (x :: k0) (y :: k0). Index l x -> Index l y -> Bool Source # geqF :: forall (x :: k0) (y :: k0). Index l x -> Index l y -> Bool Source # gtF :: forall (x :: k0) (y :: k0). Index l x -> Index l y -> Bool Source #
OrdF (Index ctx :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods compareF :: forall (x :: k0) (y :: k0). Index ctx x -> Index ctx y -> OrderingF x y Source # leqF :: forall (x :: k0) (y :: k0). Index ctx x -> Index ctx y -> Bool Source # ltF :: forall (x :: k0) (y :: k0). Index ctx x -> Index ctx y -> Bool Source # geqF :: forall (x :: k0) (y :: k0). Index ctx x -> Index ctx y -> Bool Source # gtF :: forall (x :: k0) (y :: k0). Index ctx x -> Index ctx y -> Bool Source #
OrdF f => OrdF (Compose f g :: k2 -> Type) Source #
Instance details Defined in Data.Parameterized.Classes Methods compareF :: forall (x :: k) (y :: k). Compose f g x -> Compose f g y -> OrderingF x y Source # leqF :: forall (x :: k) (y :: k). Compose f g x -> Compose f g y -> Bool Source # ltF :: forall (x :: k) (y :: k). Compose f g x -> Compose f g y -> Bool Source # geqF :: forall (x :: k) (y :: k). Compose f g x -> Compose f g y -> Bool Source # gtF :: forall (x :: k) (y :: k). Compose f g x -> Compose f g y -> Bool Source #
OrdF f => OrdF (List f :: [k] -> Type) Source #
Instance details Defined in Data.Parameterized.List Methods compareF :: forall (x :: k0) (y :: k0). List f x -> List f y -> OrderingF x y Source # leqF :: forall (x :: k0) (y :: k0). List f x -> List f y -> Bool Source # ltF :: forall (x :: k0) (y :: k0). List f x -> List f y -> Bool Source # geqF :: forall (x :: k0) (y :: k0). List f x -> List f y -> Bool Source # gtF :: forall (x :: k0) (y :: k0). List f x -> List f y -> Bool Source #
OrdF f => OrdF (Assignment f :: Ctx k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods compareF :: forall (x :: k0) (y :: k0). Assignment f x -> Assignment f y -> OrderingF x y Source # leqF :: forall (x :: k0) (y :: k0). Assignment f x -> Assignment f y -> Bool Source # ltF :: forall (x :: k0) (y :: k0). Assignment f x -> Assignment f y -> Bool Source # geqF :: forall (x :: k0) (y :: k0). Assignment f x -> Assignment f y -> Bool Source # gtF :: forall (x :: k0) (y :: k0). Assignment f x -> Assignment f y -> Bool Source #
(OrdF f, OrdF g) => OrdF (PairRepr f g :: (k1, k2) -> Type) Source #
Instance details Defined in Data.Parameterized.DataKind Methods compareF :: forall (x :: k) (y :: k). PairRepr f g x -> PairRepr f g y -> OrderingF x y Source # leqF :: forall (x :: k) (y :: k). PairRepr f g x -> PairRepr f g y -> Bool Source # ltF :: forall (x :: k) (y :: k). PairRepr f g x -> PairRepr f g y -> Bool Source # geqF :: forall (x :: k) (y :: k). PairRepr f g x -> PairRepr f g y -> Bool Source # gtF :: forall (x :: k) (y :: k). PairRepr f g x -> PairRepr f g y -> Bool Source #

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

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

data OrderingF x y where Source #

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 j k (a :: j) (b :: j) (c :: k) (d :: k). OrderingF a b -> (a ~ b => OrderingF c d) -> OrderingF c d Source #

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) Source #

toOrdering :: OrderingF x y -> Ordering Source #

Convert OrderingF to standard ordering.

fromOrdering :: Ordering -> OrderingF x x Source #

Convert standard ordering to OrderingF.

ordFCompose :: forall k l (f :: k -> Type) (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 Source #

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 -> Type) where Source #

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 Source #

Provides a show instance for each type.

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

showF :: forall tp. f tp -> String Source #

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

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

Instances

Instances details

ShowF BoolRepr Source #
Instance details Defined in Data.Parameterized.BoolRepr Methods withShow :: forall p q (tp :: k) a. p BoolRepr -> q tp -> (Show (BoolRepr tp) => a) -> a Source # showF :: forall (tp :: k). BoolRepr tp -> String Source # showsPrecF :: forall (tp :: k). Int -> BoolRepr tp -> String -> String Source #
ShowF NatRepr Source #
Instance details Defined in Data.Parameterized.NatRepr.Internal Methods withShow :: forall p q (tp :: k) a. p NatRepr -> q tp -> (Show (NatRepr tp) => a) -> a Source # showF :: forall (tp :: k). NatRepr tp -> String Source # showsPrecF :: forall (tp :: k). Int -> NatRepr tp -> String -> String Source #
ShowF SymbolRepr Source #
Instance details Defined in Data.Parameterized.SymbolRepr Methods withShow :: forall p q (tp :: k) a. p SymbolRepr -> q tp -> (Show (SymbolRepr tp) => a) -> a Source # showF :: forall (tp :: k). SymbolRepr tp -> String Source # showsPrecF :: forall (tp :: k). Int -> SymbolRepr tp -> String -> String Source #
ShowF PeanoRepr Source #
Instance details Defined in Data.Parameterized.Peano Methods withShow :: forall p q (tp :: k) a. p PeanoRepr -> q tp -> (Show (PeanoRepr tp) => a) -> a Source # showF :: forall (tp :: k). PeanoRepr tp -> String Source # showsPrecF :: forall (tp :: k). Int -> PeanoRepr tp -> String -> String Source #
ShowF (Nonce :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Nonce.Unsafe Methods withShow :: forall p q (tp :: k0) a. p Nonce -> q tp -> (Show (Nonce tp) => a) -> a Source # showF :: forall (tp :: k0). Nonce tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> Nonce tp -> String -> String Source #
Show x => ShowF (Const x :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Classes Methods withShow :: forall p q (tp :: k0) a. p (Const x) -> q tp -> (Show (Const x tp) => a) -> a Source # showF :: forall (tp :: k0). Const x tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> Const x tp -> String -> String Source #
ShowF (Nonce s :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Nonce Methods withShow :: forall p q (tp :: k0) a. p (Nonce s) -> q tp -> (Show (Nonce s tp) => a) -> a Source # showF :: forall (tp :: k0). Nonce s tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> Nonce s tp -> String -> String Source #
ShowF (Index l :: k -> Type) Source #
Instance details Defined in Data.Parameterized.List Methods withShow :: forall p q (tp :: k0) a. p (Index l) -> q tp -> (Show (Index l tp) => a) -> a Source # showF :: forall (tp :: k0). Index l tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> Index l tp -> String -> String Source #
ShowF (Index ctx :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods withShow :: forall p q (tp :: k0) a. p (Index ctx) -> q tp -> (Show (Index ctx tp) => a) -> a Source # showF :: forall (tp :: k0). Index ctx tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> Index ctx tp -> String -> String Source #
ShowF (IndexView ctx :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods withShow :: forall p q (tp :: k0) a. p (IndexView ctx) -> q tp -> (Show (IndexView ctx tp) => a) -> a Source # showF :: forall (tp :: k0). IndexView ctx tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> IndexView ctx tp -> String -> String Source #
ShowF (Size :: Ctx k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods withShow :: forall p q (tp :: k0) a. p Size -> q tp -> (Show (Size tp) => a) -> a Source # showF :: forall (tp :: k0). Size tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> Size tp -> String -> String Source #
ShowF f => ShowF (List f :: [k] -> Type) Source #
Instance details Defined in Data.Parameterized.List Methods withShow :: forall p q (tp :: k0) a. p (List f) -> q tp -> (Show (List f tp) => a) -> a Source # showF :: forall (tp :: k0). List f tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> List f tp -> String -> String Source #
ShowF f => ShowF (Assignment f :: Ctx k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods withShow :: forall p q (tp :: k0) a. p (Assignment f) -> q tp -> (Show (Assignment f tp) => a) -> a Source # showF :: forall (tp :: k0). Assignment f tp -> String Source # showsPrecF :: forall (tp :: k0). Int -> Assignment f tp -> String -> String Source #
(ShowF f, ShowF g) => ShowF (PairRepr f g :: (k1, k2) -> Type) Source #
Instance details Defined in Data.Parameterized.DataKind Methods withShow :: forall p q (tp :: k) a. p (PairRepr f g) -> q tp -> (Show (PairRepr f g tp) => a) -> a Source # showF :: forall (tp :: k). PairRepr f g tp -> String Source # showsPrecF :: forall (tp :: k). Int -> PairRepr f g tp -> String -> String Source #

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

class HashableF (f :: k -> Type) where Source #

A parameterized type that is hashable on all instances.

Minimal complete definition

hashWithSaltF

Methods

hashWithSaltF :: Int -> f tp -> Int Source #

hashF :: f tp -> Int Source #

Hash with default salt.

Instances

Instances details

HashableF BoolRepr Source #
Instance details Defined in Data.Parameterized.BoolRepr Methods hashWithSaltF :: forall (tp :: k). Int -> BoolRepr tp -> Int Source # hashF :: forall (tp :: k). BoolRepr tp -> Int Source #
HashableF NatRepr Source #
Instance details Defined in Data.Parameterized.NatRepr.Internal Methods hashWithSaltF :: forall (tp :: k). Int -> NatRepr tp -> Int Source # hashF :: forall (tp :: k). NatRepr tp -> Int Source #
HashableF SymbolRepr Source #
Instance details Defined in Data.Parameterized.SymbolRepr Methods hashWithSaltF :: forall (tp :: k). Int -> SymbolRepr tp -> Int Source # hashF :: forall (tp :: k). SymbolRepr tp -> Int Source #
HashableF PeanoRepr Source #
Instance details Defined in Data.Parameterized.Peano Methods hashWithSaltF :: forall (tp :: k). Int -> PeanoRepr tp -> Int Source # hashF :: forall (tp :: k). PeanoRepr tp -> Int Source #
HashableF (Nonce :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Nonce.Unsafe Methods hashWithSaltF :: forall (tp :: k0). Int -> Nonce tp -> Int Source # hashF :: forall (tp :: k0). Nonce tp -> Int Source #
Hashable a => HashableF (Const a :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Classes Methods hashWithSaltF :: forall (tp :: k0). Int -> Const a tp -> Int Source # hashF :: forall (tp :: k0). Const a tp -> Int Source #
HashableF (Nonce s :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Nonce Methods hashWithSaltF :: forall (tp :: k0). Int -> Nonce s tp -> Int Source # hashF :: forall (tp :: k0). Nonce s tp -> Int Source #
HashableF (Index ctx :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods hashWithSaltF :: forall (tp :: k0). Int -> Index ctx tp -> Int Source # hashF :: forall (tp :: k0). Index ctx tp -> Int Source #
HashableF f => HashableF (Assignment f :: Ctx k -> Type) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods hashWithSaltF :: forall (tp :: k0). Int -> Assignment f tp -> Int Source # hashF :: forall (tp :: k0). Assignment f tp -> Int Source #

class CoercibleF (rtp :: k -> Type) where Source #

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 Source #

Instances

Instances details

CoercibleF (Const x :: k -> Type) Source #
Instance details Defined in Data.Parameterized.Classes Methods coerceF :: forall (a :: k0) (b :: k0). Const x a -> Const x b Source #

Type function application constructor

newtype TypeAp (f :: k -> Type) (tp :: k) Source #

Captures the value obtained from applying a type to a function so that we can use parameterized class instance to provide unparameterized instances for specific types.

This is the same as Ap from Control.Applicative, but we introduce our own new type to avoid orphan instances.

Constructors

TypeAp (f tp)

Instances

Instances details

TestEquality f => Eq (TypeAp f tp) Source #
Instance details Defined in Data.Parameterized.Classes Methods (==) :: TypeAp f tp -> TypeAp f tp -> Bool # (/=) :: TypeAp f tp -> TypeAp f tp -> Bool #
OrdF f => Ord (TypeAp f tp) Source #
Instance details Defined in Data.Parameterized.Classes Methods compare :: TypeAp f tp -> TypeAp f tp -> Ordering # (<) :: TypeAp f tp -> TypeAp f tp -> Bool # (<=) :: TypeAp f tp -> TypeAp f tp -> Bool # (>) :: TypeAp f tp -> TypeAp f tp -> Bool # (>=) :: TypeAp f tp -> TypeAp f tp -> Bool # max :: TypeAp f tp -> TypeAp f tp -> TypeAp f tp # min :: TypeAp f tp -> TypeAp f tp -> TypeAp f tp #
ShowF f => Show (TypeAp f tp) Source #
Instance details Defined in Data.Parameterized.Classes Methods showsPrec :: Int -> TypeAp f tp -> ShowS # show :: TypeAp f tp -> String # showList :: [TypeAp f tp] -> ShowS #
HashableF f => Hashable (TypeAp f tp) Source #
Instance details Defined in Data.Parameterized.Classes Methods hashWithSalt :: Int -> TypeAp f tp -> Int # hash :: TypeAp f tp -> Int #

Optics generalizations

type family IndexF (m :: Type) :: k -> Type Source #

Instances

Instances details

type IndexF (Assignment f ctx) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe type IndexF (Assignment f ctx) = Index ctx
type IndexF (MapF k2 v) Source #
Instance details Defined in Data.Parameterized.Map type IndexF (MapF k2 v) = k2

type family IxValueF (m :: Type) :: k -> Type Source #

Instances

Instances details

type IxValueF (Assignment f ctx) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe type IxValueF (Assignment f ctx) = f
type IxValueF (MapF k2 v) Source #
Instance details Defined in Data.Parameterized.Map type IxValueF (MapF k2 v) = v

class IxedF k m where Source #

Parameterized generalization of the lens Ixed class.

Methods

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

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

Instances

Instances details

IxedF k (Assignment f ctx) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods ixF :: forall (x :: k). IndexF (Assignment f ctx) x -> Traversal' (Assignment f ctx) (IxValueF (Assignment f ctx) x) Source #
OrdF k => IxedF a (MapF k v) Source #	Turn a map key into a traversal that visits the indicated element in the map, if it exists.
Instance details Defined in Data.Parameterized.Map Methods ixF :: forall (x :: a). IndexF (MapF k v) x -> Traversal' (MapF k v) (IxValueF (MapF k v) x) Source #

class IxedF k m => IxedF' k m where Source #

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) Source #

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

Instances

Instances details

IxedF' k (Assignment f ctx) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods ixF' :: forall (x :: k). IndexF (Assignment f ctx) x -> Lens' (Assignment f ctx) (IxValueF (Assignment f ctx) x) Source #

class IxedF k m => AtF k m where Source #

Parameterized generalization of the lens At class.

Methods

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

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

Instances details

OrdF k => AtF a (MapF k v) Source #	Turn a map key into a lens that points into the indicated position in the map.
Instance details Defined in Data.Parameterized.Map Methods atF :: forall (x :: a). IndexF (MapF k v) x -> Lens' (MapF k v) (Maybe (IxValueF (MapF k v) x)) Source #

KnownRepr

class KnownRepr (f :: k -> Type) (ctx :: k) where Source #

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 Source #

Instances

Instances details

KnownRepr BoolRepr 'False Source #
Instance details Defined in Data.Parameterized.BoolRepr Methods knownRepr :: BoolRepr 'False Source #
KnownRepr BoolRepr 'True Source #
Instance details Defined in Data.Parameterized.BoolRepr Methods knownRepr :: BoolRepr 'True Source #
KnownNat n => KnownRepr NatRepr (n :: Nat) Source #
Instance details Defined in Data.Parameterized.NatRepr.Internal Methods knownRepr :: NatRepr n Source #
KnownSymbol s => KnownRepr SymbolRepr (s :: Symbol) Source #
Instance details Defined in Data.Parameterized.SymbolRepr Methods knownRepr :: SymbolRepr s Source #
KnownRepr PeanoRepr Z Source #
Instance details Defined in Data.Parameterized.Peano Methods knownRepr :: PeanoRepr Z Source #
KnownRepr PeanoRepr n => KnownRepr PeanoRepr (S n :: Peano) Source #
Instance details Defined in Data.Parameterized.Peano Methods knownRepr :: PeanoRepr (S n) Source #
KnownRepr (List f :: [k] -> Type) ('[] :: [k]) Source #
Instance details Defined in Data.Parameterized.List Methods knownRepr :: List f '[] Source #
KnownRepr (Assignment f :: Ctx k -> Type) (EmptyCtx :: Ctx k) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods knownRepr :: Assignment f EmptyCtx Source #
(KnownRepr f s, KnownRepr (List f) sh) => KnownRepr (List f :: [a] -> Type) (s ': sh :: [a]) Source #
Instance details Defined in Data.Parameterized.List Methods knownRepr :: List f (s ': sh) Source #
(KnownRepr (Assignment f) ctx, KnownRepr f bt) => KnownRepr (Assignment f :: Ctx k -> Type) (ctx ::> bt :: Ctx k) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods knownRepr :: Assignment f (ctx ::> bt) Source #

Re-exports

class Hashable a where #

The class of types that can be converted to a hash value.

Minimal implementation: hashWithSalt.

Minimal complete definition

Nothing

Methods

hashWithSalt :: Int -> a -> Int infixl 0 #

Return a hash value for the argument, using the given salt.

The general contract of hashWithSalt is:

If two values are equal according to the == method, then applying the hashWithSalt method on each of the two values must produce the same integer result if the same salt is used in each case.
It is not required that if two values are unequal according to the == method, then applying the hashWithSalt method on each of the two values must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal values may improve the performance of hashing-based data structures.
This method can be used to compute different hash values for the same input by providing a different salt in each application of the method. This implies that any instance that defines hashWithSalt must make use of the salt in its implementation.

hash :: a -> Int #

Like hashWithSalt, but no salt is used. The default implementation uses hashWithSalt with some default salt. Instances might want to implement this method to provide a more efficient implementation than the default implementation.

Instances

Instances details

Hashable Bool
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Bool -> Int # hash :: Bool -> Int #
Hashable Char
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Char -> Int # hash :: Char -> Int #
Hashable Double	Note: prior to `hashable-1.3.0.0`, `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Double -> Int # hash :: Double -> Int #
Hashable Float	Note: prior to `hashable-1.3.0.0`, `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Float -> Int # hash :: Float -> Int #
Hashable Int
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int -> Int # hash :: Int -> Int #
Hashable Int8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int8 -> Int # hash :: Int8 -> Int #
Hashable Int16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int16 -> Int # hash :: Int16 -> Int #
Hashable Int32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int32 -> Int # hash :: Int32 -> Int #
Hashable Int64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int64 -> Int # hash :: Int64 -> Int #
Hashable Integer
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Integer -> Int # hash :: Integer -> Int #
Hashable Natural
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> Int #
Hashable Ordering
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ordering -> Int # hash :: Ordering -> Int #
Hashable Word
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word -> Int # hash :: Word -> Int #
Hashable Word8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word8 -> Int # hash :: Word8 -> Int #
Hashable Word16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word16 -> Int # hash :: Word16 -> Int #
Hashable Word32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word32 -> Int # hash :: Word32 -> Int #
Hashable Word64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word64 -> Int # hash :: Word64 -> Int #
Hashable SomeTypeRep
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> SomeTypeRep -> Int # hash :: SomeTypeRep -> Int #
Hashable ()
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> () -> Int # hash :: () -> Int #
Hashable Void
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Void -> Int # hash :: Void -> Int #
Hashable Unique
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Unique -> Int # hash :: Unique -> Int #
Hashable Version
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> Int #
Hashable ThreadId
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ThreadId -> Int # hash :: ThreadId -> Int #
Hashable WordPtr
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WordPtr -> Int # hash :: WordPtr -> Int #
Hashable IntPtr
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntPtr -> Int # hash :: IntPtr -> Int #
Hashable Fingerprint	Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Fingerprint -> Int # hash :: Fingerprint -> Int #
Hashable ShortByteString
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ShortByteString -> Int # hash :: ShortByteString -> Int #
Hashable ByteString
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable ByteString
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable BigNat
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> BigNat -> Int # hash :: BigNat -> Int #
Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable a => Hashable [a]
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> [a] -> Int # hash :: [a] -> Int #
Hashable a => Hashable (Maybe a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Maybe a -> Int # hash :: Maybe a -> Int #
Hashable a => Hashable (Ratio a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ratio a -> Int # hash :: Ratio a -> Int #
Hashable (Ptr a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ptr a -> Int # hash :: Ptr a -> Int #
Hashable (FunPtr a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> FunPtr a -> Int # hash :: FunPtr a -> Int #
Hashable a => Hashable (Complex a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Complex a -> Int # hash :: Complex a -> Int #
Hashable a => Hashable (Min a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Min a -> Int # hash :: Min a -> Int #
Hashable a => Hashable (Max a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Max a -> Int # hash :: Max a -> Int #
Hashable a => Hashable (First a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> First a -> Int # hash :: First a -> Int #
Hashable a => Hashable (Last a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Last a -> Int # hash :: Last a -> Int #
Hashable a => Hashable (WrappedMonoid a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WrappedMonoid a -> Int # hash :: WrappedMonoid a -> Int #
Hashable a => Hashable (Option a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Option a -> Int # hash :: Option a -> Int #
Hashable (StableName a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> StableName a -> Int # hash :: StableName a -> Int #
Hashable a => Hashable (Identity a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
Hashable a => Hashable (NonEmpty a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> NonEmpty a -> Int # hash :: NonEmpty a -> Int #
Hashable (Hashed a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Hashed a -> Int # hash :: Hashed a -> Int #
Hashable (NatRepr n) Source #
Instance details Defined in Data.Parameterized.NatRepr.Internal Methods hashWithSalt :: Int -> NatRepr n -> Int # hash :: NatRepr n -> Int #
Hashable (SymbolRepr nm) Source #
Instance details Defined in Data.Parameterized.SymbolRepr Methods hashWithSalt :: Int -> SymbolRepr nm -> Int # hash :: SymbolRepr nm -> Int #
Hashable (BoolRepr n) Source #
Instance details Defined in Data.Parameterized.BoolRepr Methods hashWithSalt :: Int -> BoolRepr n -> Int # hash :: BoolRepr n -> Int #
Hashable (PeanoRepr n) Source #
Instance details Defined in Data.Parameterized.Peano Methods hashWithSalt :: Int -> PeanoRepr n -> Int # hash :: PeanoRepr n -> Int #
(Hashable a, Hashable b) => Hashable (Either a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Either a b -> Int # hash :: Either a b -> Int #
Hashable (TypeRep a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> TypeRep a -> Int # hash :: TypeRep a -> Int #
(Hashable a1, Hashable a2) => Hashable (a1, a2)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2) -> Int # hash :: (a1, a2) -> Int #
Hashable (Fixed a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Fixed a -> Int # hash :: Fixed a -> Int #
Hashable a => Hashable (Arg a b)	Note: Prior to `hashable-1.3.0.0` the hash computation included the second argument of `Arg` which wasn't consistent with its `Eq` instance. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Arg a b -> Int # hash :: Arg a b -> Int #
Hashable (Proxy a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Proxy a -> Int # hash :: Proxy a -> Int #
Hashable (Nonce tp) Source #
Instance details Defined in Data.Parameterized.Nonce.Unsafe Methods hashWithSalt :: Int -> Nonce tp -> Int # hash :: Nonce tp -> Int #
HashableF f => Hashable (Some f) Source #
Instance details Defined in Data.Parameterized.Some Methods hashWithSalt :: Int -> Some f -> Int # hash :: Some f -> Int #
(Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3) -> Int # hash :: (a1, a2, a3) -> Int #
Hashable a => Hashable (Const a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Const a b -> Int # hash :: Const a b -> Int #
HashableF f => Hashable (TypeAp f tp) Source #
Instance details Defined in Data.Parameterized.Classes Methods hashWithSalt :: Int -> TypeAp f tp -> Int # hash :: TypeAp f tp -> Int #
Hashable (Nonce s tp) Source #
Instance details Defined in Data.Parameterized.Nonce Methods hashWithSalt :: Int -> Nonce s tp -> Int # hash :: Nonce s tp -> Int #
Hashable (Index l x) Source #
Instance details Defined in Data.Parameterized.List Methods hashWithSalt :: Int -> Index l x -> Int # hash :: Index l x -> Int #
HashableF f => Hashable (Assignment f ctx) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods hashWithSalt :: Int -> Assignment f ctx -> Int # hash :: Assignment f ctx -> Int #
Hashable (Index ctx tp) Source #
Instance details Defined in Data.Parameterized.Context.Unsafe Methods hashWithSalt :: Int -> Index ctx tp -> Int # hash :: Index ctx tp -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4) => Hashable (a1, a2, a3, a4)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4) -> Int # hash :: (a1, a2, a3, a4) -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Product f g a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Product f g a -> Int # hash :: Product f g a -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Sum f g a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Sum f g a -> Int # hash :: Sum f g a -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5) => Hashable (a1, a2, a3, a4, a5)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5) -> Int # hash :: (a1, a2, a3, a4, a5) -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Compose f g a)	In general, `hash (Compose x) ≠ hash x`. However, `hashWithSalt` satisfies its variant of this equivalence.
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Compose f g a -> Int # hash :: Compose f g a -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6) => Hashable (a1, a2, a3, a4, a5, a6)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6) -> Int # hash :: (a1, a2, a3, a4, a5, a6) -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6, Hashable a7) => Hashable (a1, a2, a3, a4, a5, a6, a7)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6, a7) -> Int # hash :: (a1, a2, a3, a4, a5, a6, a7) -> Int #

isJust :: Maybe a -> Bool #

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

Examples

Expand

Basic usage:

>>> isJust (Just 3)
True

>>> isJust (Just ())
True

>>> isJust Nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (Just Nothing)
True