constraints-0.14.2: Constraint manipulation
Copyright(C) 2011-2015 Edward Kmett
LicenseBSD-style (see the file LICENSE)
MaintainerEdward Kmett <ekmett@gmail.com>
Stabilityexperimental
Portabilitynon-portable
Safe HaskellTrustworthy
LanguageHaskell2010

Data.Constraint

Description

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.

Synopsis

The Kind of Constraints

type Constraint = CONSTRAINT LiftedRep #

The kind of lifted constraints

Dictionary

data Dict :: Constraint -> * where Source #

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

Instances details
() :=> (Semigroup (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Show (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Eq (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Ord (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

a :=> (Monoid (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a) Source #

a :=> (Bounded (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a) Source #

a :=> (Enum (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a) Source #

a :=> (Read (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a) Source #

HasDict a (Dict a) Source # 
Instance details

Defined in Data.Constraint

Methods

evidence :: Dict a -> Dict a Source #

(Typeable p, p) => Data (Dict p) Source # 
Instance details

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

a => Monoid (Dict a) Source # 
Instance details

Defined in Data.Constraint

Methods

mempty :: Dict a #

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

mconcat :: [Dict a] -> Dict a #

Semigroup (Dict a) Source # 
Instance details

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 => Bounded (Dict a) Source # 
Instance details

Defined in Data.Constraint

Methods

minBound :: Dict a #

maxBound :: Dict a #

a => Enum (Dict a) Source # 
Instance details

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

a => Read (Dict a) Source # 
Instance details

Defined in Data.Constraint

Show (Dict a) Source # 
Instance details

Defined in Data.Constraint

Methods

showsPrec :: Int -> Dict a -> ShowS #

show :: Dict a -> String #

showList :: [Dict a] -> ShowS #

c => Boring (Dict c) Source # 
Instance details

Defined in Data.Constraint

Methods

boring :: Dict c #

NFData (Dict c) Source # 
Instance details

Defined in Data.Constraint

Methods

rnf :: Dict c -> () #

Eq (Dict a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

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

Ord (Dict a) Source # 
Instance details

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 #

class HasDict c e | e -> c where Source #

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

Instances

Instances details
HasDict a (Dict a) Source # 
Instance details

Defined in Data.Constraint

Methods

evidence :: Dict a -> Dict a Source #

a => HasDict b (a :- b) Source # 
Instance details

Defined in Data.Constraint

Methods

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

HasDict (Typeable k, Typeable a) (TypeRep a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

HasDict (Coercible a b) (Coercion a b) Source # 
Instance details

Defined in Data.Constraint

Methods

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

HasDict (a ~ b) (a :~: b) Source # 
Instance details

Defined in Data.Constraint

Methods

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

HasDict (a ~~ b) (a :~~: b) Source # 
Instance details

Defined in Data.Constraint

Methods

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

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

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

Operator version of withDict, with the arguments flipped

Entailment

newtype a :- b infixr 9 Source #

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

Instances details
Category (:-) Source #

Possible since GHC 7.8, when Category was made polykinded.

Instance details

Defined in Data.Constraint

Methods

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

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

() :=> (Show (a :- b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Eq (a :- b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Ord (a :- b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

a => HasDict b (a :- b) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Typeable p, Typeable q, p => q) => Data (p :- q) Source # 
Instance details

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

Show (a :- b) Source # 
Instance details

Defined in Data.Constraint

Methods

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

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

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

a => NFData (a :- b) Source # 
Instance details

Defined in Data.Constraint

Methods

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

Eq (a :- b) Source #

Assumes IncoherentInstances doesn't exist.

Instance details

Defined in Data.Constraint

Methods

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

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

Ord (a :- b) Source #

Assumes IncoherentInstances doesn't exist.

Instance details

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 #

type (⊢) = (:-) infixr 9 Source #

Type entailment, as written with a single character.

class (p => q) => p |- q Source #

The internal hom for the category of constraints.

This version can be passed around inside Dict, whereas (a => b) is impredicative

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

fails to typecheck due to the lack of impredicative polymorphism, but

foo :: Dict (Ord a |- Eq a)
foo = Dict

typechecks just fine.

Instances

Instances details
(p => q) => p |- q Source # 
Instance details

Defined in Data.Constraint

class (p, q) => p & q Source #

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 we can define an equivalent type, that converts back and forth to (,), and lets you hang instances.

Instances

Instances details
(p, q) => p & q Source # 
Instance details

Defined in Data.Constraint

weaken1 :: (a, b) :- a Source #

Weakening a constraint product

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

weaken2 :: (a, b) :- b Source #

Weakening a constraint product

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

contract :: a :- (a, a) Source #

Contracting a constraint / diagonal morphism

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

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

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

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

Constraint product

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

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

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

Transitivity of entailment

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

refl :: a :- a Source #

Reflexivity of entailment

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

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

Convert a quantified constraint into an entailment.

class Any => Bottom where Source #

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

Methods

no :: a Source #

top :: a :- () Source #

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

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

Dict is fully faithful

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

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

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

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

Instances

Instances details
Class () () Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: () :- () Source #

Class () (Functor f) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Functor f :- () Source #

Class () (Semigroup a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Semigroup a :- () Source #

Class () (Bounded a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Bounded a :- () Source #

Class () (Enum a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Enum a :- () Source #

Class () (Num a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Num a :- () Source #

Class () (Read a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Read a :- () Source #

Class () (Show a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Show a :- () Source #

Class () (Eq a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Eq a :- () Source #

Class b a => () :=> (Class b a) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Class b a Source #

Class () (b :=> a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

Class () (Class b a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Class b a :- () Source #

Class (Applicative f) (Alternative f) Source # 
Instance details

Defined in Data.Constraint

Class (Applicative f) (Monad f) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Monad f :- Applicative f Source #

Class (Functor f) (Applicative f) Source # 
Instance details

Defined in Data.Constraint

Class (Semigroup a) (Monoid a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Monoid a :- Semigroup a Source #

Class (Num a) (Fractional a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Fractional a :- Num a Source #

Class (Fractional a) (Floating a) Source # 
Instance details

Defined in Data.Constraint

Class (Eq a) (Bits a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Bits a :- Eq a Source #

Class (Eq a) (Ord a) Source # 
Instance details

Defined in Data.Constraint

Methods

cls :: Ord a :- Eq a Source #

Class (Monad f, Alternative f) (MonadPlus f) Source # 
Instance details

Defined in Data.Constraint

Methods

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

Class (Num a, Ord a) (Real a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

Class (Real a, Enum a) (Integral a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

Class (Real a, Fractional a) (RealFrac a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

Class (RealFrac a, Floating a) (RealFloat a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

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

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

Instances

Instances details
() :=> () Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- () Source #

() :=> (Alternative Maybe) Source # 
Instance details

Defined in Data.Constraint

() :=> (Alternative List) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Alternative List Source #

() :=> (Applicative (Either a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Applicative IO) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Applicative IO Source #

() :=> (Applicative Maybe) Source # 
Instance details

Defined in Data.Constraint

() :=> (Applicative ((->) a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Applicative List) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Applicative List Source #

() :=> (Functor (Either a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Functor (Const a :: Type -> Type)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Functor Identity) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Functor Identity Source #

() :=> (Functor IO) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Functor IO Source #

() :=> (Functor Maybe) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Functor Maybe Source #

() :=> (Functor ((,) a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Functor ((->) a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Functor List) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Functor List Source #

() :=> (Monad (Either a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Monad Identity) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Monad Identity Source #

() :=> (Monad IO) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Monad IO Source #

() :=> (Monad ((->) a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Monad List) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Monad List Source #

() :=> (MonadPlus Maybe) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- MonadPlus Maybe Source #

() :=> (MonadPlus List) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- MonadPlus List Source #

() :=> (Monoid Ordering) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Monoid Ordering Source #

() :=> (Monoid ()) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Monoid () Source #

() :=> (Monoid [a]) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Monoid [a] Source #

() :=> (Semigroup (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Semigroup Ordering) Source # 
Instance details

Defined in Data.Constraint

() :=> (Semigroup ()) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Semigroup () Source #

() :=> (Semigroup [a]) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Semigroup [a] Source #

() :=> (Bits Integer) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bits Integer Source #

() :=> (Bits Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bits Natural Source #

() :=> (Bits Bool) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bits Bool Source #

() :=> (Bits Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bits Int Source #

() :=> (Bits Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bits Word Source #

() :=> (Bounded Ordering) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bounded Ordering Source #

() :=> (Bounded ()) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bounded () Source #

() :=> (Bounded Bool) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bounded Bool Source #

() :=> (Bounded Char) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bounded Char Source #

() :=> (Bounded Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bounded Int Source #

() :=> (Bounded Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Bounded Word Source #

() :=> (Enum Ordering) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Ordering Source #

() :=> (Enum Integer) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Integer Source #

() :=> (Enum Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Natural Source #

() :=> (Enum ()) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum () Source #

() :=> (Enum Bool) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Bool Source #

() :=> (Enum Char) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Char Source #

() :=> (Enum Double) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Double Source #

() :=> (Enum Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Float Source #

() :=> (Enum Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Int Source #

() :=> (Enum Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Enum Word Source #

() :=> (Floating Double) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Floating Double Source #

() :=> (Floating Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Floating Float Source #

() :=> (RealFloat Double) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- RealFloat Double Source #

() :=> (RealFloat Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- RealFloat Float Source #

() :=> (Num Integer) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Num Integer Source #

() :=> (Num Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Num Natural Source #

() :=> (Num Double) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Num Double Source #

() :=> (Num Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Num Float Source #

() :=> (Num Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Num Int Source #

() :=> (Num Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Num Word Source #

() :=> (Read Ordering) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Read Ordering Source #

() :=> (Read Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Read Natural Source #

() :=> (Read ()) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Read () Source #

() :=> (Read Bool) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Read Bool Source #

() :=> (Read Char) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Read Char Source #

() :=> (Read Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Read Int Source #

() :=> (Read Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Read Word Source #

() :=> (Fractional Double) Source # 
Instance details

Defined in Data.Constraint

() :=> (Fractional Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Fractional Float Source #

() :=> (Integral Integer) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Integral Integer Source #

() :=> (Integral Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Integral Natural Source #

() :=> (Integral Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Integral Int Source #

() :=> (Integral Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Integral Word Source #

() :=> (Real Integer) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Real Integer Source #

() :=> (Real Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Real Natural Source #

() :=> (Real Double) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Real Double Source #

() :=> (Real Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Real Float Source #

() :=> (Real Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Real Int Source #

() :=> (Real Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Real Word Source #

() :=> (RealFrac Double) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- RealFrac Double Source #

() :=> (RealFrac Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- RealFrac Float Source #

() :=> (Show (a :- b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Show (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Show Ordering) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Show Ordering Source #

() :=> (Show Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Show Natural Source #

() :=> (Show ()) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Show () Source #

() :=> (Show Bool) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Show Bool Source #

() :=> (Show Char) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Show Char Source #

() :=> (Show Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Show Int Source #

() :=> (Show Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Show Word Source #

() :=> (Eq (a :- b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Eq (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Eq Integer) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Eq Integer Source #

() :=> (Eq Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Eq Natural Source #

() :=> (Eq ()) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Eq () Source #

() :=> (Eq Bool) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Eq Bool Source #

() :=> (Eq Double) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Eq Double Source #

() :=> (Eq Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Eq Float Source #

() :=> (Eq Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Eq Int Source #

() :=> (Eq Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Eq Word Source #

() :=> (Ord (a :- b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Ord (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

() :=> (Ord Integer) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord Integer Source #

() :=> (Ord Natural) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord Natural Source #

() :=> (Ord ()) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord () Source #

() :=> (Ord Bool) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord Bool Source #

() :=> (Ord Char) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord Char Source #

() :=> (Ord Double) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord Double Source #

() :=> (Ord Float) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord Float Source #

() :=> (Ord Int) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord Int Source #

() :=> (Ord Word) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Ord Word Source #

a :=> (Monoid (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a) Source #

a :=> (Bounded (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a) Source #

a :=> (Enum (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a) Source #

a :=> (Read (Dict a)) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a) Source #

b :=> a => () :=> (b :=> a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

Class b a => () :=> (Class b a) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: () :- Class b a Source #

Class () (b :=> a) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Monad m) :=> (Applicative (WrappedMonad m)) Source # 
Instance details

Defined in Data.Constraint

(Monad m) :=> (Functor (WrappedMonad m)) Source # 
Instance details

Defined in Data.Constraint

(MonadPlus m) :=> (Alternative (WrappedMonad m)) Source # 
Instance details

Defined in Data.Constraint

(Monoid a) :=> (Applicative (Const a :: Type -> Type)) Source # 
Instance details

Defined in Data.Constraint

(Monoid a) :=> (Applicative ((,) a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Monoid a) :=> (Monoid (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Monoid a) :=> (Monoid (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Monoid a) :=> (Monoid (IO a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Monoid a) :=> (Monoid (Maybe a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Semigroup a) :=> (Semigroup (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Semigroup a) :=> (Semigroup (Identity a)) Source # 
Instance details

Defined in Data.Constraint

(Semigroup a) :=> (Semigroup (IO a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Semigroup a) :=> (Semigroup (Maybe a)) Source # 
Instance details

Defined in Data.Constraint

(Bits a) :=> (Bits (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Bits a) :=> (Bits (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Bounded a) :=> (Bounded (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Bounded a) :=> (Bounded (Identity a)) Source # 
Instance details

Defined in Data.Constraint

(Enum a) :=> (Enum (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Enum a) :=> (Enum (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Floating a) :=> (Floating (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Floating a) :=> (Floating (Identity a)) Source # 
Instance details

Defined in Data.Constraint

(RealFloat a) :=> (Floating (Complex a)) Source # 
Instance details

Defined in Data.Constraint

(RealFloat a) :=> (RealFloat (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(RealFloat a) :=> (RealFloat (Identity a)) Source # 
Instance details

Defined in Data.Constraint

(RealFloat a) :=> (Num (Complex a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(RealFloat a) :=> (Fractional (Complex a)) Source # 
Instance details

Defined in Data.Constraint

(Num a) :=> (Num (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Num a) :=> (Num (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Read a) :=> (Read (Complex a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Read a) :=> (Read (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Read a) :=> (Read (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Read a) :=> (Read (Maybe a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Read a) :=> (Read [a]) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: Read a :- Read [a] Source #

(Fractional a) :=> (Fractional (Const a b)) Source # 
Instance details

Defined in Data.Constraint

(Fractional a) :=> (Fractional (Identity a)) Source # 
Instance details

Defined in Data.Constraint

(Integral a) :=> (Enum (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Integral a) :=> (Num (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Integral a) :=> (Fractional (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

(Integral a) :=> (Integral (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Integral a) :=> (Integral (Identity a)) Source # 
Instance details

Defined in Data.Constraint

(Integral a) :=> (Real (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Integral a) :=> (RealFrac (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Integral a) :=> (Ord (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Real a) :=> (Real (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Real a) :=> (Real (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(RealFrac a) :=> (RealFrac (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(RealFrac a) :=> (RealFrac (Identity a)) Source # 
Instance details

Defined in Data.Constraint

(Show a) :=> (Show (Complex a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Show a) :=> (Show (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Show a) :=> (Show (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Show a) :=> (Show (Maybe a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Show a) :=> (Show [a]) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: Show a :- Show [a] Source #

(Eq a) :=> (Eq (Complex a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Eq a) :=> (Eq (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Eq a) :=> (Eq (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Eq a) :=> (Eq (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Eq a) :=> (Eq (Maybe a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Eq a) :=> (Eq [a]) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq [a] Source #

(Ord a) :=> (Ord (Const a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Ord a) :=> (Ord (Identity a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Ord a) :=> (Ord (Maybe a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Ord a) :=> (Ord [a]) Source # 
Instance details

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord [a] Source #

(Monoid a, Monoid b) :=> (Monoid (a, b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Semigroup a, Semigroup b) :=> (Semigroup (a, b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Bounded a, Bounded b) :=> (Bounded (a, b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Read a, Read b) :=> (Read (Either a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Read a, Read b) :=> (Read (a, b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Integral a, Read a) :=> (Read (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Integral a, Show a) :=> (Show (Ratio a)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Show a, Show b) :=> (Show (Either a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Show a, Show b) :=> (Show (a, b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Eq a, Eq b) :=> (Eq (Either a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Eq a, Eq b) :=> (Eq (a, b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Ord a, Ord b) :=> (Ord (Either a b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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

(Ord a, Ord b) :=> (Ord (a, b)) Source # 
Instance details

Defined in Data.Constraint

Methods

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