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


-- | Constraint manipulation
--   
--   Constraint manipulation
@package constraints
@version 0.3


module Data.Constraint
data Constraint :: BOX

-- | Capture a dictionary for a given constraint
data Dict :: Constraint -> *
Dict :: Dict a
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
weaken1 :: (a, b) :- a

-- | Weakening a constraint product
weaken2 :: (a, b) :- b

-- | Contracting a constraint / diagonal morphism
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 (,) in the current version of GHC we
--   can't actually make instances for (,) :: Constraint -&gt; Constraint
--   -&gt; Constraint
(***) :: (a :- b) -> (c :- d) -> (a, c) :- (b, d)

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

-- | Reflexivity of entailment
--   
--   If we view '(:-)' 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 () is the terminal
--   object.
top :: a :- ()

-- | Reify the relationship between a class and its superclass constraints
--   as a class
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
class :=> b h | h -> b
ins :: :=> b h => b :- h
instance (a) => Read (Dict a)
instance Show (Dict a)
instance Ord (Dict a)
instance Eq (Dict a)
instance (a) => Monoid (Dict a)
instance a :=> Monoid (Dict a)
instance a :=> Read (Dict a)
instance (a) => Bounded (Dict a)
instance a :=> Bounded (Dict a)
instance (a) => Enum (Dict a)
instance a :=> Enum (Dict a)
instance () :=> MonadPlus Maybe
instance () :=> MonadPlus []
instance Class (Monad f) (MonadPlus f)
instance () :=> Monad IO
instance () :=> Monad (Either a)
instance () :=> Monad ((->) a)
instance () :=> Monad []
instance Class () (Monad f)
instance MonadPlus m :=> Alternative (WrappedMonad m)
instance () :=> Alternative Maybe
instance () :=> Alternative []
instance Class (Applicative f) (Alternative f)
instance Monad m :=> Applicative (WrappedMonad m)
instance Monoid a :=> Applicative ((,) a)
instance () :=> Applicative IO
instance () :=> Applicative ((->) a)
instance () :=> Applicative (Either a)
instance () :=> Applicative Maybe
instance () :=> Applicative []
instance Class (Functor f) (Applicative f)
instance Monad m :=> Functor (WrappedMonad m)
instance () :=> Functor IO
instance () :=> Functor ((,) a)
instance () :=> Functor ((->) a)
instance () :=> Functor (Either a)
instance () :=> Functor Maybe
instance () :=> Functor []
instance Class () (Functor f)
instance (Monoid a, Monoid b) :=> Monoid (a, b)
instance Monoid a :=> Monoid (Maybe a)
instance () :=> Monoid [a]
instance () :=> Monoid Ordering
instance () :=> Monoid ()
instance Class () (Monoid a)
instance () :=> RealFloat Double
instance () :=> RealFloat Float
instance Class (RealFrac a, Floating a) (RealFloat a)
instance Integral a :=> RealFrac (Ratio a)
instance () :=> RealFrac Double
instance () :=> RealFrac Float
instance Class (Real a, Fractional a) (RealFrac a)
instance RealFloat a :=> Floating (Complex a)
instance () :=> Floating Double
instance () :=> Floating Float
instance Class (Fractional a) (Floating a)
instance Integral a :=> Fractional (Ratio a)
instance RealFloat a :=> Fractional (Complex a)
instance () :=> Fractional Double
instance () :=> Fractional Float
instance Class (Num a) (Fractional a)
instance () :=> Integral Integer
instance () :=> Integral Int
instance Class (Real a, Enum a) (Integral a)
instance Integral a :=> Real (Ratio a)
instance () :=> Real Double
instance () :=> Real Float
instance () :=> Real Integer
instance () :=> Real Int
instance Class (Num a, Ord a) (Real a)
instance Integral a :=> Num (Ratio a)
instance RealFloat a :=> Num (Complex a)
instance () :=> Num Double
instance () :=> Num Float
instance () :=> Num Integer
instance () :=> Num Int
instance Class () (Num a)
instance (Bounded a, Bounded b) :=> Bounded (a, b)
instance () :=> Bounded Char
instance () :=> Bounded Int
instance () :=> Bounded Bool
instance () :=> Bounded Ordering
instance () :=> Bounded ()
instance Class () (Bounded a)
instance Integral a :=> Enum (Ratio a)
instance () :=> Enum Double
instance () :=> Enum Float
instance () :=> Enum Integer
instance () :=> Enum Int
instance () :=> Enum Char
instance () :=> Enum Ordering
instance () :=> Enum Bool
instance () :=> Enum ()
instance Class () (Enum a)
instance (Integral a, Read a) :=> Read (Ratio a)
instance (Read a, Read b) :=> Read (Either a b)
instance (Read a, Read b) :=> Read (a, b)
instance Read a :=> Read (Maybe a)
instance Read a :=> Read [a]
instance Read a :=> Read (Complex a)
instance () :=> Read Char
instance () :=> Read Ordering
instance () :=> Read Bool
instance () :=> Read ()
instance Class () (Read a)
instance () :=> Show (a :- b)
instance () :=> Show (Dict a)
instance (Integral a, Show a) :=> Show (Ratio a)
instance (Show a, Show b) :=> Show (Either a b)
instance (Show a, Show b) :=> Show (a, b)
instance Show a :=> Show (Maybe a)
instance Show a :=> Show [a]
instance Show a :=> Show (Complex a)
instance () :=> Show Char
instance () :=> Show Ordering
instance () :=> Show Bool
instance () :=> Show ()
instance Class () (Show a)
instance () :=> Ord (a :- b)
instance () :=> Ord (Dict a)
instance Integral a :=> Ord (Ratio a)
instance (Ord a, Ord b) :=> Ord (Either a b)
instance (Ord a, Ord b) :=> Ord (a, b)
instance Ord a :=> Ord [a]
instance Ord a :=> Ord (Maybe a)
instance () :=> Ord Char
instance () :=> Ord Double
instance () :=> Ord Float
instance () :=> Ord Integer
instance () :=> Ord Int
instance () :=> Ord Bool
instance () :=> Ord ()
instance Class (Eq a) (Ord a)
instance () :=> Eq (a :- b)
instance () :=> Eq (Dict a)
instance (Eq a, Eq b) :=> Eq (Either a b)
instance (Eq a, Eq b) :=> Eq (a, b)
instance Eq a :=> Eq (Ratio a)
instance Eq a :=> Eq (Complex a)
instance Eq a :=> Eq (Maybe a)
instance Eq a :=> Eq [a]
instance () :=> Eq Double
instance () :=> Eq Float
instance () :=> Eq Integer
instance () :=> Eq Bool
instance () :=> Eq Int
instance () :=> Eq ()
instance Class () (Eq a)
instance () :=> ()
instance Class () ()
instance b :=> a => () :=> (b :=> a)
instance Class b a => () :=> Class b a
instance Class () (b :=> a)
instance Class () (Class b a)
instance Show (a :- b)
instance Ord (a :- b)
instance Eq (a :- b)


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


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 Forall1 (p :: (* -> *) -> Constraint) = (p F, p M)

-- | instantiate a quantified constraint on kind <tt>* -&gt; *</tt>
inst1 :: Forall1 p :- p f