parameterized-utils-2.1.4.0: Classes and data structures for working with data-kind indexed types
Copyright(c) Galois Inc 2014-2019
MaintainerJoe Hendrix <jhendrix@galois.com>
Safe HaskellSafe
LanguageHaskell2010

Data.Parameterized.Classes

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

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
EqF (Proxy :: k -> Type) Source # 
Instance details

Defined in Data.Parameterized.Classes

Methods

eqF :: forall (a :: k0). Proxy a -> Proxy a -> Bool Source #

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

PolyEq (BoolRepr m) (BoolRepr n) Source # 
Instance details

Defined in Data.Parameterized.BoolRepr

PolyEq (PeanoRepr m) (PeanoRepr n) Source # 
Instance details

Defined in Data.Parameterized.Peano

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:

  • toOrdering (compareF x y) 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.

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 (Proxy :: k -> Type) Source # 
Instance details

Defined in Data.Parameterized.Classes

Methods

withShow :: forall p q (tp :: k0) a. p Proxy -> q tp -> (Show (Proxy tp) => a) -> a Source #

showF :: forall (tp :: k0). Proxy tp -> String Source #

showsPrecF :: forall (tp :: k0). Int -> Proxy 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 (List f sh) Source # 
Instance details

Defined in Data.Parameterized.List

type IndexF (List f sh) = Index sh
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 (List f sh) Source # 
Instance details

Defined in Data.Parameterized.List

type IxValueF (List f sh) = f
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

KnownRepr BoolRepr 'True Source # 
Instance details

Defined in Data.Parameterized.BoolRepr

KnownNat n => KnownRepr NatRepr (n :: Nat) Source # 
Instance details

Defined in Data.Parameterized.NatRepr.Internal

KnownSymbol s => KnownRepr SymbolRepr (s :: Symbol) Source # 
Instance details

Defined in Data.Parameterized.SymbolRepr

KnownRepr PeanoRepr Z Source # 
Instance details

Defined in Data.Parameterized.Peano

KnownRepr PeanoRepr n => KnownRepr PeanoRepr (S n :: Peano) Source # 
Instance details

Defined in Data.Parameterized.Peano

Methods

knownRepr :: PeanoRepr (S n) Source #

KnownRepr (Proxy :: k -> Type) (ctx :: k) Source # 
Instance details

Defined in Data.Parameterized.Classes

Methods

knownRepr :: Proxy ctx 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

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

Note: the hash is not guaranteed to be stable across library versions, operating systems or architectures. For stable hashing use named hashes: SHA256, CRC32 etc.

If you are looking for Hashable instance in time package, check time-compat

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.
  • hashWithSalt may return negative Int values.

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

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

Hashable ShortByteString 
Instance details

Defined in Data.Hashable.Class

Hashable ByteString 
Instance details

Defined in Data.Hashable.Class

Hashable ByteString 
Instance details

Defined in Data.Hashable.Class

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

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