-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Constraint manipulation
--   
--   GHC 7.4 gave us the ability to talk about <tt>ConstraintKinds</tt>.
--   They stopped crashing the compiler in GHC 7.6.
--   
--   This package provides a vocabulary for working with them.
@package constraints
@version 0.4.1.3


-- | <tt>ConstraintKinds</tt> made type classes into types of a new kind,
--   <tt>Constraint</tt>.
--   
--   <pre>
--   <a>Eq</a> :: * -&gt; <a>Constraint</a>
--   <a>Ord</a> :: * -&gt; <a>Constraint</a>
--   <a>Monad</a> :: (* -&gt; *) -&gt; <a>Constraint</a>
--   </pre>
--   
--   The need for this extension was first publicized in the paper
--   
--   <a>Scrap your boilerplate with class: extensible generic functions</a>
--   
--   by Ralf Lämmel and Simon Peyton Jones in 2005, which shoehorned all
--   the things they needed into a custom <tt>Sat</tt> typeclass.
--   
--   With <tt>ConstraintKinds</tt> we can put into code a lot of tools for
--   manipulating these new types without such awkward workarounds.
module Data.Constraint
data Constraint :: BOX

-- | Values of type <tt><a>Dict</a> p</tt> capture a dictionary for a
--   constraint of type <tt>p</tt>.
--   
--   e.g.
--   
--   <pre>
--   <a>Dict</a> :: <a>Dict</a> (<a>Eq</a> <a>Int</a>)
--   </pre>
--   
--   captures a dictionary that proves we have an:
--   
--   <pre>
--   instance <a>Eq</a> 'Int
--   </pre>
--   
--   Pattern matching on the <a>Dict</a> constructor will bring this
--   instance into scope.
data Dict :: Constraint -> *
Dict :: Dict a

-- | This is the type of entailment.
--   
--   <tt>a <a>:-</a> b</tt> is read as <tt>a</tt> "entails" <tt>b</tt>.
--   
--   With this we can actually build a category for <a>Constraint</a>
--   resolution.
--   
--   e.g.
--   
--   Because <tt><a>Eq</a> a</tt> is a superclass of <tt><a>Ord</a> a</tt>,
--   we can show that <tt><a>Ord</a> a</tt> entails <tt><a>Eq</a> a</tt>.
--   
--   Because <tt>instance <a>Ord</a> a =&gt; <a>Ord</a> [a]</tt> exists, we
--   can show that <tt><a>Ord</a> a</tt> entails <tt><a>Ord</a> [a]</tt> as
--   well.
--   
--   This relationship is captured in the <a>:-</a> entailment type here.
--   
--   Since <tt>p <a>:-</a> p</tt> and entailment composes, <a>:-</a> forms
--   the arrows of a <a>Category</a> of constraints. However,
--   <a>Category</a> only because 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
--   <a>Category</a> has some very interesting properties. Notably, in the
--   absence of <tt>IncoherentInstances</tt>, 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
--   <tt><a>Ord</a> a <a>:-</a> <a>Eq</a> [a]</tt>, 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 <tt><a>Ord</a> a <a>:-</a> <a>Eq</a> a</tt> via
--   the superclass relationship, and them from <tt><a>Eq</a> a <a>:-</a>
--   <a>Eq</a> [a]</tt> via the instance, or we can go from <tt><a>Ord</a>
--   a <a>:-</a> <a>Ord</a> [a]</tt> via the instance then from
--   <tt><a>Ord</a> [a] <a>:-</a> <a>Eq</a> [a]</tt> through the superclass
--   relationship and this diagram by definition must "commute".
--   
--   Diagrammatically,
--   
--   <pre>
--          Ord a
--      ins /     \ cls
--         v       v
--   Ord [a]     Eq a
--      cls \     / ins
--           v   v
--          Eq [a]
--   </pre>
--   
--   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.
newtype (:-) a b
Sub :: (a => Dict b) -> (:-) a b

-- | Given that <tt>a :- b</tt>, derive something that needs a context
--   <tt>b</tt>, using the context <tt>a</tt>
(\\) :: a => (b => r) -> (a :- b) -> r

-- | Weakening a constraint product
--   
--   The category of constraints is Cartesian. We can forget information.
weaken1 :: (a, b) :- a

-- | Weakening a constraint product
--   
--   The category of constraints is Cartesian. We can forget information.
weaken2 :: (a, b) :- b

-- | Contracting a constraint / diagonal morphism
--   
--   The category of constraints is Cartesian. We can reuse information.
contract :: a :- (a, a)

-- | Constraint product
--   
--   <pre>
--   trans weaken1 (f &amp;&amp;&amp; g) = f
--   trans weaken2 (f &amp;&amp;&amp; g) = g
--   </pre>
(&&&) :: (a :- b) -> (a :- c) -> a :- (b, c)

-- | due to the hack for the kind of <tt>(,)</tt> in the current version of
--   GHC we can't actually make instances for <tt>(,) :: Constraint -&gt;
--   Constraint -&gt; Constraint</tt>, but <tt>(,)</tt> is a bifunctor on
--   the category of constraints. This lets us map over both sides.
(***) :: (a :- b) -> (c :- d) -> (a, c) :- (b, d)

-- | Transitivity of entailment
--   
--   If we view <tt>(<a>:-</a>)</tt> as a Constraint-indexed category, then
--   this is <tt>(<a>.</a>)</tt>
trans :: (b :- c) -> (a :- b) -> a :- c

-- | Reflexivity of entailment
--   
--   If we view <tt>(<a>:-</a>)</tt> as a Constraint-indexed category, then
--   this is <a>id</a>
refl :: a :- a

-- | Every constraint implies truth
--   
--   These are the terminal arrows of the category, and <tt>()</tt> is the
--   terminal object.
--   
--   Given any constraint there is a unique entailment of the <tt>()</tt>
--   constraint from that constraint.
top :: a :- ()

-- | A bad type coercion lets you derive any constraint you want.
--   
--   These are the initial arrows of the category and <tt>(() ~ Bool)</tt>
--   is the initial object
--   
--   This demonstrates the law of classical logic <a>"ex falso
--   quodlibet"</a>
bottom :: (() ~ Bool) :- c

-- | Apply an entailment to a dictionary.
--   
--   From a category theoretic perspective <a>Dict</a> is a functor that
--   maps from the category of constraints (with arrows in <a>:-</a>) to
--   the category Hask of Haskell data types.
mapDict :: (a :- b) -> Dict a -> Dict b

-- | This functor is fully faithful, which is to say that given any
--   function you can write <tt>Dict a -&gt; Dict b</tt> there also exists
--   an entailment <tt>a :- b</tt> in the category of constraints that you
--   can build.
unmapDict :: (Dict a -> Dict b) -> a :- b

-- | Reify the relationship between a class and its superclass constraints
--   as a class
--   
--   Given a definition such as
--   
--   <pre>
--   class Foo a =&gt; Bar a
--   </pre>
--   
--   you can capture the relationship between 'Bar a' and its superclass
--   'Foo a' with
--   
--   <pre>
--   instance <a>Class</a> (Foo a) (Bar a) where <a>cls</a> = <a>Sub</a> <a>Dict</a>
--   </pre>
--   
--   Now the user can use 'cls :: Bar a :- Foo a'
class Class b h | h -> b
cls :: Class b h => h :- b

-- | Reify the relationship between an instance head and its body as a
--   class
--   
--   Given a definition such as
--   
--   <pre>
--   instance Foo a =&gt; Foo [a]
--   </pre>
--   
--   you can capture the relationship between the instance head and its
--   body with
--   
--   <pre>
--   instance Foo a <a>:=&gt;</a> Foo [a] where <a>ins</a> = <a>Sub</a> <a>Dict</a>
--   </pre>
class (:=>) b h | h -> b
ins :: (:=>) b h => b :- h
instance GHC.Classes.Eq (Data.Constraint.Dict a)
instance GHC.Classes.Ord (Data.Constraint.Dict a)
instance GHC.Show.Show (Data.Constraint.Dict a)
instance a => GHC.Read.Read (Data.Constraint.Dict a)
instance (Data.Typeable.Internal.Typeable p, p) => Data.Data.Data (Data.Constraint.Dict p)
instance (Data.Typeable.Internal.Typeable p, Data.Typeable.Internal.Typeable q, p, q) => Data.Data.Data (p Data.Constraint.:- q)
instance Control.Category.Category (Data.Constraint.:-)
instance GHC.Classes.Eq (a Data.Constraint.:- b)
instance GHC.Classes.Ord (a Data.Constraint.:- b)
instance GHC.Show.Show (a Data.Constraint.:- b)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (Data.Constraint.Class b a)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (b Data.Constraint.:=> a)
instance Data.Constraint.Class b a => (() :: GHC.Prim.Constraint) Data.Constraint.:=> Data.Constraint.Class b a
instance (b Data.Constraint.:=> a) => (() :: GHC.Prim.Constraint) Data.Constraint.:=> (b Data.Constraint.:=> a)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (() :: GHC.Prim.Constraint)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> (() :: GHC.Prim.Constraint)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Classes.Eq a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Eq ()
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Eq GHC.Types.Int
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Eq GHC.Types.Bool
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Eq GHC.Integer.Type.Integer
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Eq GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Eq GHC.Types.Double
instance GHC.Classes.Eq a Data.Constraint.:=> GHC.Classes.Eq [a]
instance GHC.Classes.Eq a Data.Constraint.:=> GHC.Classes.Eq (GHC.Base.Maybe a)
instance GHC.Classes.Eq a Data.Constraint.:=> GHC.Classes.Eq (Data.Complex.Complex a)
instance GHC.Classes.Eq a Data.Constraint.:=> GHC.Classes.Eq (GHC.Real.Ratio a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) Data.Constraint.:=> GHC.Classes.Eq (a, b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) Data.Constraint.:=> GHC.Classes.Eq (Data.Either.Either a b)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Eq (Data.Constraint.Dict a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Eq (a Data.Constraint.:- b)
instance Data.Constraint.Class (GHC.Classes.Eq a) (GHC.Classes.Ord a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord ()
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord GHC.Types.Bool
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord GHC.Types.Int
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord GHC.Integer.Type.Integer
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord GHC.Types.Double
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord GHC.Types.Char
instance GHC.Classes.Ord a Data.Constraint.:=> GHC.Classes.Ord (GHC.Base.Maybe a)
instance GHC.Classes.Ord a Data.Constraint.:=> GHC.Classes.Ord [a]
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) Data.Constraint.:=> GHC.Classes.Ord (a, b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) Data.Constraint.:=> GHC.Classes.Ord (Data.Either.Either a b)
instance GHC.Real.Integral a Data.Constraint.:=> GHC.Classes.Ord (GHC.Real.Ratio a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord (Data.Constraint.Dict a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Classes.Ord (a Data.Constraint.:- b)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Show.Show a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Show.Show ()
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Show.Show GHC.Types.Bool
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Show.Show GHC.Types.Ordering
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Show.Show GHC.Types.Char
instance GHC.Show.Show a Data.Constraint.:=> GHC.Show.Show (Data.Complex.Complex a)
instance GHC.Show.Show a Data.Constraint.:=> GHC.Show.Show [a]
instance GHC.Show.Show a Data.Constraint.:=> GHC.Show.Show (GHC.Base.Maybe a)
instance (GHC.Show.Show a, GHC.Show.Show b) Data.Constraint.:=> GHC.Show.Show (a, b)
instance (GHC.Show.Show a, GHC.Show.Show b) Data.Constraint.:=> GHC.Show.Show (Data.Either.Either a b)
instance (GHC.Real.Integral a, GHC.Show.Show a) Data.Constraint.:=> GHC.Show.Show (GHC.Real.Ratio a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Show.Show (Data.Constraint.Dict a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Show.Show (a Data.Constraint.:- b)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Read.Read a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Read.Read ()
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Read.Read GHC.Types.Bool
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Read.Read GHC.Types.Ordering
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Read.Read GHC.Types.Char
instance GHC.Read.Read a Data.Constraint.:=> GHC.Read.Read (Data.Complex.Complex a)
instance GHC.Read.Read a Data.Constraint.:=> GHC.Read.Read [a]
instance GHC.Read.Read a Data.Constraint.:=> GHC.Read.Read (GHC.Base.Maybe a)
instance (GHC.Read.Read a, GHC.Read.Read b) Data.Constraint.:=> GHC.Read.Read (a, b)
instance (GHC.Read.Read a, GHC.Read.Read b) Data.Constraint.:=> GHC.Read.Read (Data.Either.Either a b)
instance (GHC.Real.Integral a, GHC.Read.Read a) Data.Constraint.:=> GHC.Read.Read (GHC.Real.Ratio a)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Enum.Enum a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Enum ()
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Enum GHC.Types.Bool
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Enum GHC.Types.Ordering
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Enum GHC.Types.Char
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Enum GHC.Types.Int
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Enum GHC.Integer.Type.Integer
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Enum GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Enum GHC.Types.Double
instance GHC.Real.Integral a Data.Constraint.:=> GHC.Enum.Enum (GHC.Real.Ratio a)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Enum.Bounded a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Bounded ()
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Bounded GHC.Types.Ordering
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Bounded GHC.Types.Bool
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Bounded GHC.Types.Int
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Enum.Bounded GHC.Types.Char
instance (GHC.Enum.Bounded a, GHC.Enum.Bounded b) Data.Constraint.:=> GHC.Enum.Bounded (a, b)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Num.Num a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Num.Num GHC.Types.Int
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Num.Num GHC.Integer.Type.Integer
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Num.Num GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Num.Num GHC.Types.Double
instance GHC.Float.RealFloat a Data.Constraint.:=> GHC.Num.Num (Data.Complex.Complex a)
instance GHC.Real.Integral a Data.Constraint.:=> GHC.Num.Num (GHC.Real.Ratio a)
instance Data.Constraint.Class (GHC.Num.Num a, GHC.Classes.Ord a) (GHC.Real.Real a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.Real GHC.Types.Int
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.Real GHC.Integer.Type.Integer
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.Real GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.Real GHC.Types.Double
instance GHC.Real.Integral a Data.Constraint.:=> GHC.Real.Real (GHC.Real.Ratio a)
instance Data.Constraint.Class (GHC.Real.Real a, GHC.Enum.Enum a) (GHC.Real.Integral a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.Integral GHC.Types.Int
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.Integral GHC.Integer.Type.Integer
instance Data.Constraint.Class (GHC.Num.Num a) (GHC.Real.Fractional a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.Fractional GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.Fractional GHC.Types.Double
instance GHC.Float.RealFloat a Data.Constraint.:=> GHC.Real.Fractional (Data.Complex.Complex a)
instance GHC.Real.Integral a Data.Constraint.:=> GHC.Real.Fractional (GHC.Real.Ratio a)
instance Data.Constraint.Class (GHC.Real.Fractional a) (GHC.Float.Floating a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Float.Floating GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Float.Floating GHC.Types.Double
instance GHC.Float.RealFloat a Data.Constraint.:=> GHC.Float.Floating (Data.Complex.Complex a)
instance Data.Constraint.Class (GHC.Real.Real a, GHC.Real.Fractional a) (GHC.Real.RealFrac a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.RealFrac GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Real.RealFrac GHC.Types.Double
instance GHC.Real.Integral a Data.Constraint.:=> GHC.Real.RealFrac (GHC.Real.Ratio a)
instance Data.Constraint.Class (GHC.Real.RealFrac a, GHC.Float.Floating a) (GHC.Float.RealFloat a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Float.RealFloat GHC.Types.Float
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Float.RealFloat GHC.Types.Double
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Base.Monoid a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Monoid ()
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Monoid GHC.Types.Ordering
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Monoid [a]
instance GHC.Base.Monoid a Data.Constraint.:=> GHC.Base.Monoid (GHC.Base.Maybe a)
instance (GHC.Base.Monoid a, GHC.Base.Monoid b) Data.Constraint.:=> GHC.Base.Monoid (a, b)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Base.Functor f)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Functor []
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Functor GHC.Base.Maybe
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Functor (Data.Either.Either a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Functor ((->) a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Functor ((,) a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Functor GHC.Types.IO
instance GHC.Base.Monad m Data.Constraint.:=> GHC.Base.Functor (Control.Applicative.WrappedMonad m)
instance Data.Constraint.Class (GHC.Base.Functor f) (GHC.Base.Applicative f)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Applicative []
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Applicative GHC.Base.Maybe
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Applicative (Data.Either.Either a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Applicative ((->) a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Applicative GHC.Types.IO
instance GHC.Base.Monoid a Data.Constraint.:=> GHC.Base.Applicative ((,) a)
instance GHC.Base.Monad m Data.Constraint.:=> GHC.Base.Applicative (Control.Applicative.WrappedMonad m)
instance Data.Constraint.Class (GHC.Base.Applicative f) (GHC.Base.Alternative f)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Alternative []
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Alternative GHC.Base.Maybe
instance GHC.Base.MonadPlus m Data.Constraint.:=> GHC.Base.Alternative (Control.Applicative.WrappedMonad m)
instance Data.Constraint.Class (() :: GHC.Prim.Constraint) (GHC.Base.Monad f)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Monad []
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Monad ((->) a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Monad (Data.Either.Either a)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.Monad GHC.Types.IO
instance Data.Constraint.Class (GHC.Base.Monad f) (GHC.Base.MonadPlus f)
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.MonadPlus []
instance (() :: GHC.Prim.Constraint) Data.Constraint.:=> GHC.Base.MonadPlus GHC.Base.Maybe
instance a Data.Constraint.:=> GHC.Enum.Enum (Data.Constraint.Dict a)
instance a => GHC.Enum.Enum (Data.Constraint.Dict a)
instance a Data.Constraint.:=> GHC.Enum.Bounded (Data.Constraint.Dict a)
instance a => GHC.Enum.Bounded (Data.Constraint.Dict a)
instance a Data.Constraint.:=> GHC.Read.Read (Data.Constraint.Dict a)
instance a Data.Constraint.:=> GHC.Base.Monoid (Data.Constraint.Dict a)
instance a => GHC.Base.Monoid (Data.Constraint.Dict a)


module Data.Constraint.Unsafe

-- | Coerce a dictionary unsafely from one type to another
unsafeCoerceConstraint :: a :- b

-- | Coerce a dictionary unsafely from one type to a newtype of that type
unsafeDerive :: Newtype n o => (o -> n) -> t o :- t n

-- | Coerce a dictionary unsafely from a newtype of a type to the base type
unsafeUnderive :: Newtype n o => (o -> n) -> t n :- t o

-- | Construct an Applicative instance from a Monad
unsafeApplicative :: Monad m => (Applicative m => m a) -> m a

-- | Construct an Alternative instance from a MonadPlus
unsafeAlternative :: MonadPlus m => (Alternative m => m a) -> m a


-- | This module uses a trick to provide quantification over constraints.
module Data.Constraint.Forall

-- | A quantified constraint
type Forall (p :: * -> Constraint) = (p A, p B)

-- | instantiate a quantified constraint on kind <tt>*</tt>
inst :: Forall p :- p a
type ForallF (p :: * -> Constraint) (f :: * -> *) = (p (f A), p (f B))
instF :: ForallF p f :- p (f a)
type Forall1 (p :: (* -> *) -> Constraint) = (p F, p M)

-- | instantiate a quantified constraint on kind <tt>* -&gt; *</tt>
inst1 :: Forall1 p :- p f
type ForallT (p :: * -> Constraint) (t :: (* -> *) -> * -> *) = (p (t F A), p (t M B))
instT :: ForallT p t :- p (t f a)
