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


-- | Wrap together data and it's constraints.
--   
--   This package, together with its dependency <a>polydata-core</a>,
--   allows one to pass data, particularly functions, together with a
--   constraint which describes how polymorphic that data is. This
--   constraint can then be used in a generic way to produce quite
--   polymorphic functions, for example, a "map" function that works on a
--   pair of two different types.
--   
--   See <a>Data.Poly</a> for a basic tutorial.
@package polydata
@version 0.2

module Data.Poly.Functor

-- | A very generic class for a map function on heterogeneous data
--   structures (i.e. those with differing types).
--   
--   This allows you to do things like:
--   
--   <pre>
--   &gt;&gt;&gt; hmap triple (3 :: Int, 4.5 :: Float)
--   (9 :: Int, 13.5 :: Float)
--   </pre>
--   
--   <a>hmap</a> takes as it's function a <a>Poly</a>, as of course you'd
--   want a polymorphic function.
--   
--   The return type defined in the class is very vague, indeed it's just
--   <tt>t</tt> to be detailed in the instances, because unlike a normal
--   <a>map</a> function, how <a>hmap</a> changes the type depends a lot on
--   the type it's applied to, there's no simple <tt>f a -&gt; f b</tt>.
--   
--   Currently only instances are defined are for 2 and 3 tuples, nag me if
--   you want larger ones.
--   
--   It's worth noting how the instances are defined, for example, for the
--   2 tuples, there are 3 instances defined. This is primarily to help
--   type inference. We don't know too much about the types <a>hmap</a>
--   will produce, but we do know, if we feed <a>hmap</a> a pair, we should
--   get a pair back. Likewise, if the result of <a>hmap</a> is a pair,
--   then the input should be a pair.
--   
--   So we provide both instances where the input is a pair, and when the
--   output is a pair. In both of these instances, we then in the
--   constraints section (which happens after instance selection) ensure
--   the other argument is also a pair.
--   
--   The "know both are pairs already" case just needs to be added as a
--   specific overlapping instance so the compiler has a most specific
--   match when it already knows both input and output are pairs.
class PolyFunctor t
hmap :: forall c. (PolyFunctor t, PolyFunctorConstraint c t) => Poly c -> t
instance Control.IndexT.Tuple.IsTuple 2 a => Data.Poly.Functor.PolyFunctor (a -> (b0, b1))
instance Control.IndexT.Tuple.IsTuple 2 b => Data.Poly.Functor.PolyFunctor ((a0, a1) -> b)
instance Data.Poly.Functor.PolyFunctor ((a0, a1) -> (b0, b1))
instance Control.IndexT.Tuple.IsTuple 3 a => Data.Poly.Functor.PolyFunctor (a -> (b0, b1, b2))
instance Control.IndexT.Tuple.IsTuple 3 b => Data.Poly.Functor.PolyFunctor ((a0, a1, a2) -> b)
instance Data.Poly.Functor.PolyFunctor ((a0, a1, a2) -> (b0, b1, b2))

module Data.Poly.Function

-- | 'mkPolyHomoFunc1 simply represents a function from <tt>t -&gt; t</tt>,
--   possibly constrained.
--   
--   For example, this is how to write a polymorphic version of "triple":
--   
--   <pre>
--   mkPolyHomoFunc1 @Num (*3)
--   </pre>
mkPolyHomoFunc1 :: forall c. (forall t. c t => t -> t) -> Poly ((IsHomoFunc 1) &&& ((Arg 0) `IxConstrainBy` c))

-- | 'mkPolyFunc1 is for one argument functions with differing arguments.
--   
--   For example, this is how to write a polymorphic version of
--   <a>toInteger</a>:
--   
--   <pre>
--   mkPolyFunc1 @Integral @(Equal Integer) toInteger
--   </pre>
--   
--   Note that something like <tt>Just :: t -&gt; Maybe t</tt> this
--   convience function is not helpful for, because the two constraints you
--   pass here are separate.
mkPolyFunc1 :: forall c1 c2. (forall t1 t2. (c1 t1, c2 t2) => t1 -> t2) -> Poly (((IsFunc 1) &&& ((Arg 0) `IxConstrainBy` c1)) &&& ((Result 1) `IxConstrainBy` c2))

-- | 'mkPolyHomoFunc2 simply represents a function from <tt>t -&gt; t -&gt;
--   t</tt>, possibly constrained.
--   
--   For example, this is how to write a polymorphic version of "add":
--   
--   <pre>
--   mkPolyHomoFunc2 @Num (+)
--   </pre>
mkPolyHomoFunc2 :: forall c. (forall t. c t => t -> t -> t) -> Poly ((IsHomoFunc 2) &&& ((Arg 0) `IxConstrainBy` c))

-- | 'mkPolyArgFunc2 represents a function from <tt>t -&gt; t -&gt; r</tt>,
--   with two constraints, one for the arguments, one for the result.
--   
--   For example, this is how to write a polymorphic version of "eq":
--   
--   <pre>
--   mkPolyHomoArgFunc2 @Eq @(Equal Bool) (==)
--   </pre>
mkPolyHomoArgFunc2 :: forall c1 c2. (forall t1 t2. (c1 t1, c2 t2) => t1 -> t1 -> t2) -> Poly (((IsHomoArgFunc 2) &&& ((Arg 0) `IxConstrainBy` c1)) &&& ((Result 2) `IxConstrainBy` c2))

-- | Handy type class for expressing an "is equal to" constraint, because
--   as a class it can be partially applied.
--   
--   For example, whilst <tt>Num</tt> is a constraint function from <tt>(*
--   -&gt; Constraint)</tt> such that <tt>(Num t)</tt> succeeds only if
--   <tt>t</tt> is a <tt>Num</tt>, <tt>Equal Int</tt> is a constraint
--   function such that <tt>(Equal Int) t</tt> succeeds only if <tt>t</tt>
--   is an <tt>Int</tt>.
--   
--   For example:
--   
--   <pre>
--   mkPolyFunc1 @Integral @(Equal Integer) toInteger
--   </pre>
--   
--   Is a polymorphic <a>toInteger</a> function.
class (a ~ b) => Equal a b

-- | The empty constraint:
--   
--   <pre>
--   Empty a
--   </pre>
--   
--   always succeeds.
class Empty a
instance (Control.IndexT.Function.IsFunc 1 f, c1 (Control.IndexT.IndexT 0 f), c2 (Control.IndexT.Function.ResultT 1 f)) => Data.Poly.Function.PolyFunc1Constraints c1 c2 f
instance (Control.IndexT.Function.IsHomoFunc 1 f, c (Control.IndexT.IndexT 0 f)) => Data.Poly.Function.PolyHomoFunc1Constraints c f
instance a ~ b => Data.Poly.Function.Equal a b
instance Data.Poly.Function.Empty a