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


-- | Write functions in tacit (pointless) style using Applicative and De Bruijn index notation.
--   
--   Write functions in tacit (pointless) style using Applicative and De
--   Bruijn index notation.
@package data-function-tacit
@version 0.1.0.0


-- | Write functions in tacit (pointless) style using Applicative and De
--   Bruijn index notation.
--   
--   Examples:
--   
--   <ul>
--   <li><pre> \f x y -&gt; f x == f y = lurryA @N3 ((==) &lt;$&gt; (_1
--   &lt;*&gt; _2) &lt;*&gt; (_1 &lt;*&gt; _3)) </pre></li>
--   <li><pre> \f g x -&gt; f x (g x) = lurryA @N3 ((_1 &lt;*&gt; _3)
--   &lt;*&gt; (_2 &lt;*&gt; _3)) </pre></li>
--   <li><pre> \a b -&gt; b = lurryA @N2 _2 </pre></li>
--   </ul>
--   
--   This module is intended to be used with <a>Applicative</a> but does
--   not export it.
--   
--   Opposite to De Bruijn indices, this module orders the arguments from
--   the outside-in, rather than the inside-out (or left-to-right instead
--   of right-to-left). For example, the conventional <tt>λλλ3 1 (2 1)</tt>
--   is instead <tt>λλλ1 3 (2 3)</tt>.
--   
--   The first argument is <tt>z</tt>, the second argument <tt>z.s</tt>,
--   the third argument <tt>z.s.s</tt>, and so on. For the first few
--   arguments convenient names have been defined, such as <a>_1</a>,
--   <a>_2</a>, <a>_3</a>, and so on.
--   
--   To export a function use <a>lurryA</a>. You must specify the arity of
--   the function, which is intended to be done with TypeApplications (new
--   in GHC 8.0). <tt>lurryA @(S Z) f</tt> says the arity of <tt>f</tt> is
--   one, <tt>lurryA @(S (S Z)) f</tt> says the arity is two, and so on.
--   For convenience the first few Peano numbers have been given aliases,
--   such as <tt>N1</tt>, <tt>N2</tt>, <tt>N3</tt>, and so on.
--   
--   You can write all functions with <tt>&lt;*&gt;</tt> and
--   <tt>&lt;$&gt;</tt> from <tt>Applicative</tt> — should be able to, yet
--   unproven.
--   
--   There is a type inference problem with functions where the highest
--   index does not match the function arity, such as <tt>const</tt>. To
--   resolve this ambiguity you must give an explicit signature. For
--   example: <tt>lurryA @N2 (_1 :: (a, (b, c)) -&gt; a)</tt>.
--   
--   TODO:
--   
--   <ul>
--   <li>Construction rules for rewriting functions into this tacit form.
--   More precise than just examples. Would demonstrate that any function
--   can be written in this tacit form.</li>
--   <li>An inverse for <tt>lurry</tt>, <tt>unlurry</tt>. Type inference
--   seems difficult.</li>
--   <li>Inference problem when the highest index does not match the
--   function arity.</li>
--   </ul>
--   
--   NOTES:
--   
--   <ul>
--   <li>The implementation would be simpler and less prone to inference
--   problems if GHC had closed classes. Given a type family <tt>F</tt>, a
--   corresponding value-level implementation may exist for <tt>x -&gt; F
--   x</tt>. This implementation can be given by a class and an instance
--   corresponding to each case in the type family. However, if the type
--   family is closed and we only have open classes, we cannot always
--   define corresponding instances which are unambiguous. An example of
--   this correspondence is 'Lurried'/'Lurry'.</li>
--   </ul>
module Data.Function.Tacit

-- | "Curry" a function type with a tuple-list argument.
--   
--   Example:
--   
--   <pre>
--   Lurried ((a, (b, (c, ()))) -&gt; d) ~ a -&gt; b -&gt; c -&gt; d
--   </pre>

-- | "Curry" a function with a tuple-list argument.
--   
--   This type class should be treated as closed. The instances provided
--   map exactly to the type-level recursion defined by <a>Lurried</a>.
--   
--   Use <a>lurryA</a> instead of <a>lurry</a>, which helps resolve
--   ambiguity.
class Lurry f
lurry :: Lurry f => f -> Lurried f

-- | Next argument.
s :: (a, b) -> b

-- | First argument.
z :: (a, b) -> a

-- | First argument.
_1 :: (a, b) -> a

-- | Second argument.
_2 :: (a, (b, c)) -> b

-- | Third argument.
_3 :: (a, (b, (c, d))) -> c

-- | Fourth argument.
_4 :: (a, (b, (c, (e, f)))) -> e

-- | Fifth argument.
_5 :: (a, (b, (c, (e, (f, g))))) -> f

-- | Sixth argument.
_6 :: (a, (b, (c, (e, (f, (g, h)))))) -> g

-- | Seventh argument.
_7 :: (a, (b, (c, (e, (f, (g, (h, i))))))) -> h

-- | Eighth argument.
_8 :: (a, (b, (c, (e, (f, (g, (h, (i, j)))))))) -> i

-- | Ninth argument.
_9 :: (a, (b, (c, (e, (f, (g, (h, (i, (j, k))))))))) -> j

-- | Peano numbers.
data Nat
[Z] :: Nat
[S] :: Nat -> Nat

-- | The Peano number 0.
type N0 = Z

-- | The Peano number 1.
type N1 = S N0

-- | The Peano number 2.
type N2 = S N1

-- | The Peano number 3.
type N3 = S N2

-- | The Peano number 4.
type N4 = S N3

-- | The Peano number 5.
type N5 = S N4

-- | The Peano number 6.
type N6 = S N5

-- | The Peano number 7.
type N7 = S N6

-- | The Peano number 8.
type N8 = S N7

-- | The Peano number 9.
type N9 = S N8

-- | Cap a tuple-list to the given length.
--   
--   Example:
--   
--   <pre>
--   Take N2 (a, (b, (c, d))) ~ (a, (b, ()))
--   </pre>

-- | Lurry a function of given arity. This arity must match exactly to the
--   highest index used to avoid ambiguity (see the module docs).
--   Otherwise, an explicit signature for the function must be given.
--   
--   Example:
--   
--   <pre>
--   lurryA @N2 (_1 &lt;*&gt; _2) = ($)
--   </pre>
lurryA :: (Take n p ~ p', p ~ p', Lurry (p -> r)) => (p -> r) -> Lurried (p' -> r)

-- | Increments the argument indices of a function.
--   
--   Example:
--   
--   <pre>
--   shift (_1 &lt;*&gt; _2) = _2 &lt;*&gt; _3
--   </pre>
shift :: ((b, c) -> d) -> (a, (b, c)) -> d
instance Data.Function.Tacit.Lurry ((a, ()) -> r)
instance Data.Function.Tacit.Lurry ((b, cs) -> r) => Data.Function.Tacit.Lurry ((a, (b, cs)) -> r)