Data.Constraint

ConstraintKinds made type classes into types of a new kind, Constraint.

Eq :: * -> Constraint
Ord :: * -> Constraint
Monad :: (* -> *) -> Constraint

The need for this extension was first publicized in the paper

Scrap your boilerplate with class: extensible generic functions

by Ralf Lämmel and Simon Peyton Jones in 2005, which shoehorned all the things they needed into a custom Sat typeclass.

With ConstraintKinds we can put into code a lot of tools for manipulating these new types without such awkward workarounds.

The Kind of Constraints

data Constraint

The kind of constraints, like Show a

Dictionary

data Dict :: Constraint -> * where

Values of type Dict p capture a dictionary for a constraint of type p.

e.g.

Dict :: Dict (Eq Int)

captures a dictionary that proves we have an:

instance Eq Int

Pattern matching on the Dict constructor will bring this instance into scope.

Constructors

Dict :: a => Dict a

Instances

a :=> (Monoid (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a)

a :=> (Read (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a)

a :=> (Bounded (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a)

a :=> (Enum (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a)

() :=> (Eq (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Eq (Dict a)

() :=> (Ord (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Ord (Dict a)

() :=> (Show (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Show (Dict a)

() :=> (Semigroup (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Semigroup (Dict a)

HasDict a (Dict a)

Defined in Data.Constraint

Methods

evidence :: Dict a -> Dict a

a => Bounded (Dict a)

Defined in Data.Constraint

Methods

minBound :: Dict a

maxBound :: Dict a

a => Enum (Dict a)

Defined in Data.Constraint

Methods

succ :: Dict a -> Dict a

pred :: Dict a -> Dict a

toEnum :: Int -> Dict a

fromEnum :: Dict a -> Int

enumFrom :: Dict a -> [Dict a]

enumFromThen :: Dict a -> Dict a -> [Dict a]

enumFromTo :: Dict a -> Dict a -> [Dict a]

enumFromThenTo :: Dict a -> Dict a -> Dict a -> [Dict a]

Eq (Dict a)

Defined in Data.Constraint

Methods

(==) :: Dict a -> Dict a -> Bool

(/=) :: Dict a -> Dict a -> Bool

(Typeable p, p) => Data (Dict p)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dict p -> c (Dict p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dict p)

toConstr :: Dict p -> Constr

dataTypeOf :: Dict p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dict p))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dict p))

gmapT :: (forall b. Data b => b -> b) -> Dict p -> Dict p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQ :: (forall d. Data d => d -> u) -> Dict p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dict p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

Ord (Dict a)

Defined in Data.Constraint

Methods

compare :: Dict a -> Dict a -> Ordering

(<) :: Dict a -> Dict a -> Bool

(<=) :: Dict a -> Dict a -> Bool

(>) :: Dict a -> Dict a -> Bool

(>=) :: Dict a -> Dict a -> Bool

max :: Dict a -> Dict a -> Dict a

min :: Dict a -> Dict a -> Dict a

a => Read (Dict a)

Defined in Data.Constraint

Methods

readsPrec :: Int -> ReadS (Dict a)

readList :: ReadS [Dict a]

readPrec :: ReadPrec (Dict a)

readListPrec :: ReadPrec [Dict a]

Show (Dict a)

Defined in Data.Constraint

Methods

showsPrec :: Int -> Dict a -> ShowS

show :: Dict a -> String

showList :: [Dict a] -> ShowS

Semigroup (Dict a)

Defined in Data.Constraint

Methods

(<>) :: Dict a -> Dict a -> Dict a

sconcat :: NonEmpty (Dict a) -> Dict a

stimes :: Integral b => b -> Dict a -> Dict a

a => Monoid (Dict a)

Defined in Data.Constraint

Methods

mempty :: Dict a

mappend :: Dict a -> Dict a -> Dict a

mconcat :: [Dict a] -> Dict a

NFData (Dict c)

Defined in Data.Constraint

Methods

rnf :: Dict c -> ()

class HasDict c e | e -> c where

Witnesses that a value of type e contains evidence of the constraint c.

Mainly intended to allow (\\) to be overloaded, since it's a useful operator.

Methods

evidence :: e -> Dict c

Instances

HasDict a (Dict a)

Defined in Data.Constraint

Methods

evidence :: Dict a -> Dict a

a => HasDict b (a :- b)

Defined in Data.Constraint

Methods

evidence :: (a :- b) -> Dict b

HasDict (Typeable k, Typeable a) (TypeRep a)

Defined in Data.Constraint

Methods

evidence :: TypeRep a -> Dict (Typeable k, Typeable a)

HasDict (a ~ b) (a :~: b)

Defined in Data.Constraint

Methods

evidence :: (a :~: b) -> Dict (a ~ b)

HasDict (Coercible a b) (Coercion a b)

Defined in Data.Constraint

Methods

evidence :: Coercion a b -> Dict (Coercible a b)

HasDict (a ~~ b) (a :~~: b)

Defined in Data.Constraint

Methods

evidence :: (a :~~: b) -> Dict (a ~~ b)

withDict :: HasDict c e => e -> (c => r) -> r

From a Dict, takes a value in an environment where the instance witnessed by the Dict is in scope, and evaluates it.

Essentially a deconstruction of a Dict into its continuation-style form.

Can also be used to deconstruct an entailment, a :- b, using a context a.

withDict :: Dict c -> (c => r) -> r
withDict :: a => (a :- c) -> (c => r) -> r

(\\) :: HasDict c e => (c => r) -> e -> r infixl 1

Operator version of withDict, with the arguments flipped

Entailment

newtype a :- b infixr 9

This is the type of entailment.

a :- b is read as a "entails" b.

With this we can actually build a category for Constraint resolution.

e.g.

Because Eq a is a superclass of Ord a, we can show that Ord a entails Eq a.

Because instance Ord a => Ord [a] exists, we can show that Ord a entails Ord [a] as well.

This relationship is captured in the :- entailment type here.

Since p :- p and entailment composes, :- forms the arrows of a Category of constraints. However, Category only became sufficiently general to support this instance in GHC 7.8, so prior to 7.8 this instance is unavailable.

But due to the coherence of instance resolution in Haskell, this Category has some very interesting properties. Notably, in the absence of IncoherentInstances, this category is "thin", which is to say that between any two objects (constraints) there is at most one distinguishable arrow.

This means that for instance, even though there are two ways to derive Ord a :- Eq [a], the answers from these two paths _must_ by construction be equal. This is a property that Haskell offers that is pretty much unique in the space of languages with things they call "type classes".

What are the two ways?

Well, we can go from Ord a :- Eq a via the superclass relationship, and then from Eq a :- Eq [a] via the instance, or we can go from Ord a :- Ord [a] via the instance then from Ord [a] :- Eq [a] through the superclass relationship and this diagram by definition must "commute".

Diagrammatically,

                   Ord a
               ins /     \ cls
                  v       v
            Ord [a]     Eq a
               cls \     / ins
                    v   v
                   Eq [a]

This safety net ensures that pretty much anything you can write with this library is sensible and can't break any assumptions on the behalf of library authors.

Constructors

Sub (a => Dict b)

Instances

Category (:-)

Possible since GHC 7.8, when Category was made polykinded.

Defined in Data.Constraint

Methods

id :: forall (a :: k). a :- a

(.) :: forall (b :: k) (c :: k) (a :: k). (b :- c) -> (a :- b) -> a :- c

() :=> (Eq (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Eq (a :- b)

() :=> (Ord (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Ord (a :- b)

() :=> (Show (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Show (a :- b)

a => HasDict b (a :- b)

Defined in Data.Constraint

Methods

evidence :: (a :- b) -> Dict b

Eq (a :- b)

Assumes IncoherentInstances doesn't exist.

Defined in Data.Constraint

Methods

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

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

(Typeable p, Typeable q, p, q) => Data (p :- q)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> (p :- q) -> c (p :- q)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (p :- q)

toConstr :: (p :- q) -> Constr

dataTypeOf :: (p :- q) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (p :- q))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (p :- q))

gmapT :: (forall b. Data b => b -> b) -> (p :- q) -> p :- q

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r

gmapQ :: (forall d. Data d => d -> u) -> (p :- q) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (p :- q) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

Ord (a :- b)

Assumes IncoherentInstances doesn't exist.

Defined in Data.Constraint

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

Show (a :- b)

Defined in Data.Constraint

Methods

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

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

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

a => NFData (a :- b)

Defined in Data.Constraint

Methods

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

type (⊢) = (:-) infixr 9

Type entailment, as written with a single character.

weaken1 :: (a, b) :- a

Weakening a constraint product

The category of constraints is Cartesian. We can forget information.

weaken2 :: (a, b) :- b

Weakening a constraint product

The category of constraints is Cartesian. We can forget information.

contract :: a :- (a, a)

Contracting a constraint / diagonal morphism

The category of constraints is Cartesian. We can reuse information.

strengthen1 :: Dict b -> (a :- c) -> a :- (b, c)

strengthen2 :: Dict b -> (a :- c) -> a :- (c, b)

(&&&) :: (a :- b) -> (a :- c) -> a :- (b, c)

Constraint product

trans weaken1 (f &&& g) = f
trans weaken2 (f &&& g) = g

(***) :: (a :- b) -> (c :- d) -> (a, c) :- (b, d)

due to the hack for the kind of (,) in the current version of GHC we can't actually make instances for (,) :: Constraint -> Constraint -> Constraint, but (,) is a bifunctor on the category of constraints. This lets us map over both sides.

trans :: (b :- c) -> (a :- b) -> a :- c

Transitivity of entailment

If we view (:-) as a Constraint-indexed category, then this is (.)

refl :: a :- a

Reflexivity of entailment

If we view (:-) as a Constraint-indexed category, then this is id

implied :: forall a b. (a => b) => a :- b

Convert a quantified constraint into an entailment.

Only available on GHC 8.6 or later.

class Any => Bottom where

Any inhabits every kind, including Constraint but is uninhabited, making it impossible to define an instance.

Methods

no :: a

top :: a :- ()

Every constraint implies truth

These are the terminal arrows of the category, and () is the terminal object.

Given any constraint there is a unique entailment of the () constraint from that constraint.

bottom :: Bottom :- a

This demonstrates the law of classical logic "ex falso quodlibet"

Dict is fully faithful

mapDict :: (a :- b) -> Dict a -> Dict b

Apply an entailment to a dictionary.

From a category theoretic perspective Dict is a functor that maps from the category of constraints (with arrows in :-) to the category Hask of Haskell data types.

unmapDict :: (Dict a -> Dict b) -> a :- b

This functor is fully faithful, which is to say that given any function you can write Dict a -> Dict b there also exists an entailment a :- b in the category of constraints that you can build.

Reflection

class Class b h | h -> b where

Reify the relationship between a class and its superclass constraints as a class

Given a definition such as

class Foo a => Bar a

you can capture the relationship between 'Bar a' and its superclass 'Foo a' with

instance Class (Foo a) (Bar a) where cls = Sub Dict

Now the user can use 'cls :: Bar a :- Foo a'

Methods

cls :: h :- b

Instances

Class () ()

Defined in Data.Constraint

Methods

cls :: () :- ()

Class () (Bounded a)

Defined in Data.Constraint

Methods

cls :: Bounded a :- ()

Class () (Enum a)

Defined in Data.Constraint

Methods

cls :: Enum a :- ()

Class () (Eq a)

Defined in Data.Constraint

Methods

cls :: Eq a :- ()

Class () (Functor f)

Defined in Data.Constraint

Methods

cls :: Functor f :- ()

Class () (Num a)

Defined in Data.Constraint

Methods

cls :: Num a :- ()

Class () (Read a)

Defined in Data.Constraint

Methods

cls :: Read a :- ()

Class () (Show a)

Defined in Data.Constraint

Methods

cls :: Show a :- ()

Class () (Semigroup a)

Defined in Data.Constraint

Methods

cls :: Semigroup a :- ()

Class b a => () :=> (Class b a)

Defined in Data.Constraint

Methods

ins :: () :- Class b a

Class () (b :=> a)

Defined in Data.Constraint

Methods

cls :: (b :=> a) :- ()

Class () (Class b a)

Defined in Data.Constraint

Methods

cls :: Class b a :- ()

Class (Eq a) (Bits a)

Defined in Data.Constraint

Methods

cls :: Bits a :- Eq a

Class (Eq a) (Ord a)

Defined in Data.Constraint

Methods

cls :: Ord a :- Eq a

Class (Fractional a) (Floating a)

Defined in Data.Constraint

Methods

cls :: Floating a :- Fractional a

Class (Functor f) (Applicative f)

Defined in Data.Constraint

Methods

cls :: Applicative f :- Functor f

Class (Num a) (Fractional a)

Defined in Data.Constraint

Methods

cls :: Fractional a :- Num a

Class (Applicative f) (Monad f)

Defined in Data.Constraint

Methods

cls :: Monad f :- Applicative f

Class (Applicative f) (Alternative f)

Defined in Data.Constraint

Methods

cls :: Alternative f :- Applicative f

Class (Semigroup a) (Monoid a)

Defined in Data.Constraint

Methods

cls :: Monoid a :- Semigroup a

Class (Monad f, Alternative f) (MonadPlus f)

Defined in Data.Constraint

Methods

cls :: MonadPlus f :- (Monad f, Alternative f)

Class (Num a, Ord a) (Real a)

Defined in Data.Constraint

Methods

cls :: Real a :- (Num a, Ord a)

Class (Real a, Fractional a) (RealFrac a)

Defined in Data.Constraint

Methods

cls :: RealFrac a :- (Real a, Fractional a)

Class (Real a, Enum a) (Integral a)

Defined in Data.Constraint

Methods

cls :: Integral a :- (Real a, Enum a)

Class (RealFrac a, Floating a) (RealFloat a)

Defined in Data.Constraint

Methods

cls :: RealFloat a :- (RealFrac a, Floating a)

class b :=> h | h -> b where infixr 9

Reify the relationship between an instance head and its body as a class

Given a definition such as

instance Foo a => Foo [a]

you can capture the relationship between the instance head and its body with

instance Foo a :=> Foo [a] where ins = Sub Dict

Methods

ins :: b :- h

Instances

() :=> ()

Defined in Data.Constraint

Methods

ins :: () :- ()

a :=> (Monoid (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a)

a :=> (Read (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a)

a :=> (Bounded (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a)

a :=> (Enum (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a)

() :=> (Bounded Bool)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Bool

() :=> (Bounded Char)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Char

() :=> (Bounded Int)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Int

() :=> (Bounded Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Ordering

() :=> (Bounded Word)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Word

() :=> (Bounded ())

Defined in Data.Constraint

Methods

ins :: () :- Bounded ()

() :=> (Enum Bool)

Defined in Data.Constraint

Methods

ins :: () :- Enum Bool

() :=> (Enum Char)

Defined in Data.Constraint

Methods

ins :: () :- Enum Char

() :=> (Enum Double)

Defined in Data.Constraint

Methods

ins :: () :- Enum Double

() :=> (Enum Float)

Defined in Data.Constraint

Methods

ins :: () :- Enum Float

() :=> (Enum Int)

Defined in Data.Constraint

Methods

ins :: () :- Enum Int

() :=> (Enum Integer)

Defined in Data.Constraint

Methods

ins :: () :- Enum Integer

() :=> (Enum Natural)

Defined in Data.Constraint

Methods

ins :: () :- Enum Natural

() :=> (Enum Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Enum Ordering

() :=> (Enum Word)

Defined in Data.Constraint

Methods

ins :: () :- Enum Word

() :=> (Enum ())

Defined in Data.Constraint

Methods

ins :: () :- Enum ()

() :=> (Eq Bool)

Defined in Data.Constraint

Methods

ins :: () :- Eq Bool

() :=> (Eq Double)

Defined in Data.Constraint

Methods

ins :: () :- Eq Double

() :=> (Eq Float)

Defined in Data.Constraint

Methods

ins :: () :- Eq Float

() :=> (Eq Int)

Defined in Data.Constraint

Methods

ins :: () :- Eq Int

() :=> (Eq Integer)

Defined in Data.Constraint

Methods

ins :: () :- Eq Integer

() :=> (Eq Natural)

Defined in Data.Constraint

Methods

ins :: () :- Eq Natural

() :=> (Eq Word)

Defined in Data.Constraint

Methods

ins :: () :- Eq Word

() :=> (Eq ())

Defined in Data.Constraint

Methods

ins :: () :- Eq ()

() :=> (Eq (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Eq (a :- b)

() :=> (Eq (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Eq (Dict a)

() :=> (Floating Double)

Defined in Data.Constraint

Methods

ins :: () :- Floating Double

() :=> (Floating Float)

Defined in Data.Constraint

Methods

ins :: () :- Floating Float

() :=> (Fractional Double)

Defined in Data.Constraint

Methods

ins :: () :- Fractional Double

() :=> (Fractional Float)

Defined in Data.Constraint

Methods

ins :: () :- Fractional Float

() :=> (Integral Int)

Defined in Data.Constraint

Methods

ins :: () :- Integral Int

() :=> (Integral Integer)

Defined in Data.Constraint

Methods

ins :: () :- Integral Integer

() :=> (Integral Natural)

Defined in Data.Constraint

Methods

ins :: () :- Integral Natural

() :=> (Integral Word)

Defined in Data.Constraint

Methods

ins :: () :- Integral Word

() :=> (Monad ((->) a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: () :- Monad ((->) a)

() :=> (Monad [])

Defined in Data.Constraint

Methods

ins :: () :- Monad []

() :=> (Monad IO)

Defined in Data.Constraint

Methods

ins :: () :- Monad IO

() :=> (Monad (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Monad (Either a)

() :=> (Monad Identity)

Defined in Data.Constraint

Methods

ins :: () :- Monad Identity

() :=> (Functor ((->) a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: () :- Functor ((->) a)

() :=> (Functor [])

Defined in Data.Constraint

Methods

ins :: () :- Functor []

() :=> (Functor Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Functor Maybe

() :=> (Functor IO)

Defined in Data.Constraint

Methods

ins :: () :- Functor IO

() :=> (Functor (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Either a)

() :=> (Functor ((,) a))

Defined in Data.Constraint

Methods

ins :: () :- Functor ((,) a)

() :=> (Functor Identity)

Defined in Data.Constraint

Methods

ins :: () :- Functor Identity

() :=> (Functor (Const a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Const a)

() :=> (Num Double)

Defined in Data.Constraint

Methods

ins :: () :- Num Double

() :=> (Num Float)

Defined in Data.Constraint

Methods

ins :: () :- Num Float

() :=> (Num Int)

Defined in Data.Constraint

Methods

ins :: () :- Num Int

() :=> (Num Integer)

Defined in Data.Constraint

Methods

ins :: () :- Num Integer

() :=> (Num Natural)

Defined in Data.Constraint

Methods

ins :: () :- Num Natural

() :=> (Num Word)

Defined in Data.Constraint

Methods

ins :: () :- Num Word

() :=> (Ord Bool)

Defined in Data.Constraint

Methods

ins :: () :- Ord Bool

() :=> (Ord Char)

Defined in Data.Constraint

Methods

ins :: () :- Ord Char

() :=> (Ord Double)

Defined in Data.Constraint

Methods

ins :: () :- Ord Double

() :=> (Ord Float)

Defined in Data.Constraint

Methods

ins :: () :- Ord Float

() :=> (Ord Int)

Defined in Data.Constraint

Methods

ins :: () :- Ord Int

() :=> (Ord Integer)

Defined in Data.Constraint

Methods

ins :: () :- Ord Integer

() :=> (Ord Natural)

Defined in Data.Constraint

Methods

ins :: () :- Ord Natural

() :=> (Ord Word)

Defined in Data.Constraint

Methods

ins :: () :- Ord Word

() :=> (Ord ())

Defined in Data.Constraint

Methods

ins :: () :- Ord ()

() :=> (Ord (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Ord (a :- b)

() :=> (Ord (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Ord (Dict a)

() :=> (Read Bool)

Defined in Data.Constraint

Methods

ins :: () :- Read Bool

() :=> (Read Char)

Defined in Data.Constraint

Methods

ins :: () :- Read Char

() :=> (Read Int)

Defined in Data.Constraint

Methods

ins :: () :- Read Int

() :=> (Read Natural)

Defined in Data.Constraint

Methods

ins :: () :- Read Natural

() :=> (Read Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Read Ordering

() :=> (Read Word)

Defined in Data.Constraint

Methods

ins :: () :- Read Word

() :=> (Read ())

Defined in Data.Constraint

Methods

ins :: () :- Read ()

() :=> (Real Double)

Defined in Data.Constraint

Methods

ins :: () :- Real Double

() :=> (Real Float)

Defined in Data.Constraint

Methods

ins :: () :- Real Float

() :=> (Real Int)

Defined in Data.Constraint

Methods

ins :: () :- Real Int

() :=> (Real Integer)

Defined in Data.Constraint

Methods

ins :: () :- Real Integer

() :=> (Real Natural)

Defined in Data.Constraint

Methods

ins :: () :- Real Natural

() :=> (Real Word)

Defined in Data.Constraint

Methods

ins :: () :- Real Word

() :=> (RealFloat Double)

Defined in Data.Constraint

Methods

ins :: () :- RealFloat Double

() :=> (RealFloat Float)

Defined in Data.Constraint

Methods

ins :: () :- RealFloat Float

() :=> (RealFrac Double)

Defined in Data.Constraint

Methods

ins :: () :- RealFrac Double

() :=> (RealFrac Float)

Defined in Data.Constraint

Methods

ins :: () :- RealFrac Float

() :=> (Show Bool)

Defined in Data.Constraint

Methods

ins :: () :- Show Bool

() :=> (Show Char)

Defined in Data.Constraint

Methods

ins :: () :- Show Char

() :=> (Show Int)

Defined in Data.Constraint

Methods

ins :: () :- Show Int

() :=> (Show Natural)

Defined in Data.Constraint

Methods

ins :: () :- Show Natural

() :=> (Show Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Show Ordering

() :=> (Show Word)

Defined in Data.Constraint

Methods

ins :: () :- Show Word

() :=> (Show ())

Defined in Data.Constraint

Methods

ins :: () :- Show ()

() :=> (Show (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Show (a :- b)

() :=> (Show (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Show (Dict a)

() :=> (Applicative ((->) a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: () :- Applicative ((->) a)

() :=> (Applicative [])

Defined in Data.Constraint

Methods

ins :: () :- Applicative []

() :=> (Applicative Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Applicative Maybe

() :=> (Applicative IO)

Defined in Data.Constraint

Methods

ins :: () :- Applicative IO

() :=> (Applicative (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Applicative (Either a)

() :=> (Semigroup [a])

Defined in Data.Constraint

Methods

ins :: () :- Semigroup [a]

() :=> (Semigroup Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Semigroup Ordering

() :=> (Semigroup ())

Defined in Data.Constraint

Methods

ins :: () :- Semigroup ()

() :=> (Semigroup (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Semigroup (Dict a)

() :=> (Monoid [a])

Defined in Data.Constraint

Methods

ins :: () :- Monoid [a]

() :=> (Monoid Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Monoid Ordering

() :=> (Monoid ())

Defined in Data.Constraint

Methods

ins :: () :- Monoid ()

() :=> (Bits Bool)

Defined in Data.Constraint

Methods

ins :: () :- Bits Bool

() :=> (Bits Int)

Defined in Data.Constraint

Methods

ins :: () :- Bits Int

() :=> (Bits Integer)

Defined in Data.Constraint

Methods

ins :: () :- Bits Integer

() :=> (Bits Natural)

Defined in Data.Constraint

Methods

ins :: () :- Bits Natural

() :=> (Bits Word)

Defined in Data.Constraint

Methods

ins :: () :- Bits Word

() :=> (Alternative [])

Defined in Data.Constraint

Methods

ins :: () :- Alternative []

() :=> (Alternative Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Alternative Maybe

() :=> (MonadPlus [])

Defined in Data.Constraint

Methods

ins :: () :- MonadPlus []

() :=> (MonadPlus Maybe)

Defined in Data.Constraint

Methods

ins :: () :- MonadPlus Maybe

b :=> a => () :=> (b :=> a)

Defined in Data.Constraint

Methods

ins :: () :- (b :=> a)

Class b a => () :=> (Class b a)

Defined in Data.Constraint

Methods

ins :: () :- Class b a

Class () (b :=> a)

Defined in Data.Constraint

Methods

cls :: (b :=> a) :- ()

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

Defined in Data.Constraint

Methods

ins :: Bounded a :- Bounded (Const a b)

(Bounded a) :=> (Bounded (Identity a))

Defined in Data.Constraint

Methods

ins :: Bounded a :- Bounded (Identity a)

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

Defined in Data.Constraint

Methods

ins :: Enum a :- Enum (Const a b)

(Enum a) :=> (Enum (Identity a))

Defined in Data.Constraint

Methods

ins :: Enum a :- Enum (Identity a)

(Eq a) :=> (Eq (Const a b))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Const a b)

(Eq a) :=> (Eq (Identity a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Identity a)

(Eq a) :=> (Eq (Ratio a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Ratio a)

(Eq a) :=> (Eq (Complex a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Complex a)

(Eq a) :=> (Eq (Maybe a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Maybe a)

(Eq a) :=> (Eq [a])

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq [a]

(Floating a) :=> (Floating (Const a b))

Defined in Data.Constraint

Methods

ins :: Floating a :- Floating (Const a b)

(Floating a) :=> (Floating (Identity a))

Defined in Data.Constraint

Methods

ins :: Floating a :- Floating (Identity a)

(Fractional a) :=> (Fractional (Const a b))

Defined in Data.Constraint

Methods

ins :: Fractional a :- Fractional (Const a b)

(Fractional a) :=> (Fractional (Identity a))

Defined in Data.Constraint

Methods

ins :: Fractional a :- Fractional (Identity a)

(Integral a) :=> (RealFrac (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- RealFrac (Ratio a)

(Integral a) :=> (Fractional (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Fractional (Ratio a)

(Integral a) :=> (Integral (Const a b))

Defined in Data.Constraint

Methods

ins :: Integral a :- Integral (Const a b)

(Integral a) :=> (Integral (Identity a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Integral (Identity a)

(Integral a) :=> (Real (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Real (Ratio a)

(Integral a) :=> (Num (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Num (Ratio a)

(Integral a) :=> (Enum (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Enum (Ratio a)

(Integral a) :=> (Ord (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Ord (Ratio a)

(Monad m) :=> (Applicative (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Applicative (WrappedMonad m)

(Monad m) :=> (Functor (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Functor (WrappedMonad m)

(Num a) :=> (Num (Const a b))

Defined in Data.Constraint

Methods

ins :: Num a :- Num (Const a b)

(Num a) :=> (Num (Identity a))

Defined in Data.Constraint

Methods

ins :: Num a :- Num (Identity a)

(Ord a) :=> (Ord (Const a b))

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord (Const a b)

(Ord a) :=> (Ord (Identity a))

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord (Identity a)

(Ord a) :=> (Ord [a])

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord [a]

(Ord a) :=> (Ord (Maybe a))

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord (Maybe a)

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

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Const a b)

(Read a) :=> (Read (Identity a))

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Identity a)

(Read a) :=> (Read (Maybe a))

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Maybe a)

(Read a) :=> (Read [a])

Defined in Data.Constraint

Methods

ins :: Read a :- Read [a]

(Read a) :=> (Read (Complex a))

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Complex a)

(Real a) :=> (Real (Const a b))

Defined in Data.Constraint

Methods

ins :: Real a :- Real (Const a b)

(Real a) :=> (Real (Identity a))

Defined in Data.Constraint

Methods

ins :: Real a :- Real (Identity a)

(RealFloat a) :=> (RealFloat (Const a b))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- RealFloat (Const a b)

(RealFloat a) :=> (RealFloat (Identity a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- RealFloat (Identity a)

(RealFloat a) :=> (Floating (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Floating (Complex a)

(RealFloat a) :=> (Fractional (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Fractional (Complex a)

(RealFloat a) :=> (Num (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Num (Complex a)

(RealFrac a) :=> (RealFrac (Const a b))

Defined in Data.Constraint

Methods

ins :: RealFrac a :- RealFrac (Const a b)

(RealFrac a) :=> (RealFrac (Identity a))

Defined in Data.Constraint

Methods

ins :: RealFrac a :- RealFrac (Identity a)

(Show a) :=> (Show (Const a b))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Const a b)

(Show a) :=> (Show (Identity a))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Identity a)

(Show a) :=> (Show (Maybe a))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Maybe a)

(Show a) :=> (Show [a])

Defined in Data.Constraint

Methods

ins :: Show a :- Show [a]

(Show a) :=> (Show (Complex a))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Complex a)

(Semigroup a) :=> (Semigroup (IO a))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (IO a)

(Semigroup a) :=> (Semigroup (Identity a))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (Identity a)

(Semigroup a) :=> (Semigroup (Const a b))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (Const a b)

(Semigroup a) :=> (Semigroup (Maybe a))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (Maybe a)

(Monoid a) :=> (Applicative (Const a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Applicative (Const a)

(Monoid a) :=> (Applicative ((,) a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Applicative ((,) a)

(Monoid a) :=> (Monoid (IO a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (IO a)

(Monoid a) :=> (Monoid (Identity a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (Identity a)

(Monoid a) :=> (Monoid (Const a b))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (Const a b)

(Monoid a) :=> (Monoid (Maybe a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (Maybe a)

(Bits a) :=> (Bits (Const a b))

Defined in Data.Constraint

Methods

ins :: Bits a :- Bits (Const a b)

(Bits a) :=> (Bits (Identity a))

Defined in Data.Constraint

Methods

ins :: Bits a :- Bits (Identity a)

(MonadPlus m) :=> (Alternative (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: MonadPlus m :- Alternative (WrappedMonad m)

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

Defined in Data.Constraint

Methods

ins :: (Bounded a, Bounded b) :- Bounded (a, b)

(Eq a, Eq b) :=> (Eq (Either a b))

Defined in Data.Constraint

Methods

ins :: (Eq a, Eq b) :- Eq (Either a b)

(Eq a, Eq b) :=> (Eq (a, b))

Defined in Data.Constraint

Methods

ins :: (Eq a, Eq b) :- Eq (a, b)

(Integral a, Read a) :=> (Read (Ratio a))

Defined in Data.Constraint

Methods

ins :: (Integral a, Read a) :- Read (Ratio a)

(Integral a, Show a) :=> (Show (Ratio a))

Defined in Data.Constraint

Methods

ins :: (Integral a, Show a) :- Show (Ratio a)

(Ord a, Ord b) :=> (Ord (Either a b))

Defined in Data.Constraint

Methods

ins :: (Ord a, Ord b) :- Ord (Either a b)

(Ord a, Ord b) :=> (Ord (a, b))

Defined in Data.Constraint

Methods

ins :: (Ord a, Ord b) :- Ord (a, b)

(Read a, Read b) :=> (Read (Either a b))

Defined in Data.Constraint

Methods

ins :: (Read a, Read b) :- Read (Either a b)

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

Defined in Data.Constraint

Methods

ins :: (Read a, Read b) :- Read (a, b)

(Show a, Show b) :=> (Show (Either a b))

Defined in Data.Constraint

Methods

ins :: (Show a, Show b) :- Show (Either a b)

(Show a, Show b) :=> (Show (a, b))

Defined in Data.Constraint

Methods

ins :: (Show a, Show b) :- Show (a, b)

(Semigroup a, Semigroup b) :=> (Semigroup (a, b))

Defined in Data.Constraint

Methods

ins :: (Semigroup a, Semigroup b) :- Semigroup (a, b)

(Monoid a, Monoid b) :=> (Monoid (a, b))

Defined in Data.Constraint

Methods

ins :: (Monoid a, Monoid b) :- Monoid (a, b)