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


-- | simple alternative to type classes
--   
@package cluss
@version 0.1

module Type.Cluss

-- | <tt><a>In</a> as</tt> is a <i>cluss</i>, where <tt>as</tt> is a list
--   of type patterns. Normally, <tt>as</tt> is concrete and does not
--   contain any type variables, like <tt>In [Binary (-&gt;) (Show
--   &gt;|&lt; This), Type String] a</tt>.
--   
--   When <tt>a</tt> satisfies <tt>In as a</tt>, you can use the method
--   <tt><a>proj</a> :: <a>AllOf</a> as f -&gt; f a</tt>.
--   
--   Clusses call for some language extensions. Basically, this language
--   pragma will do.
--   
--   <pre>
--   {-# LANGUAGE DataKinds, FlexibleContexts, TypeOperators #-}
--   </pre>
--   
--   Internally, "type pattern matching" is executed by <a>Where</a>, a
--   closed type family, which cannot check if a type satisfies a
--   constraint. If <tt>as</tt> has many type patterns that can match
--   <tt>a</tt>, only the first one matches <tt>a</tt>.
class In (as :: [*]) (a :: k)
proj :: In as a => AllOf as f -> f a

-- | The empty type <tt>Type a</tt> is a type pattern. For example, the
--   type pattern <tt>Type Int</tt> corresponds to <tt>instance C Int where
--   ...</tt> (<tt>C</tt> is a type class). Note that the type variable
--   <tt>a</tt> can be of any kind.
data Type (a :: k)

-- | The empty type <tt>a &lt;| p</tt> is a type pattern, where <tt>a</tt>
--   is a type constructor, and <tt>p</tt> is a constraint function for the
--   type variables for the constructor <tt>a</tt>. For example, the type
--   pattern <tt>[] &lt;| Show</tt> corresponds to <tt>instance (Show a)
--   =&gt; C [a] where ...</tt> (<tt>C</tt> is a type class).
--   
--   You can replace any of <a>Unary</a>, <a>Binary</a>, ..., <a>Senary</a>
--   with <tt>&lt;|</tt>, but you can sometimes save the effort of
--   annotating kinds using <a>Unary</a>, <a>Binary</a>, ..., <a>Senary</a>
--   instead of <tt>&lt;|</tt>, especially when using <tt>PolyKinds</tt>
--   extension, because kinds of parameters are restricted in <a>Unary</a>,
--   <a>Binary</a>, ..., <a>Senary</a>.
data (<|) (a :: k) (p :: l)

-- | <tt>a <tt>&lt;|</tt> p</tt>, with <tt>a</tt> being of the kind <tt>i
--   -&gt; k</tt> and <tt>p</tt>, <tt>i -&gt; <a>Constraint</a></tt>.
type Unary (a :: i -> k) (p :: i -> Constraint) = a <| p

-- | <tt>a <tt>&lt;|</tt> p</tt>, with <tt>a</tt> being of the kind <tt>i
--   -&gt; i' -&gt; k</tt> and <tt>p</tt>, <tt>i -&gt; i' -&gt;
--   <a>Constraint</a></tt>.
type Binary (a :: i -> i' -> k) (p :: i -> i' -> Constraint) = a <| p

-- | <tt>a <tt>&lt;|</tt> p</tt>, with <tt>a</tt> being of the kind <tt>i
--   -&gt; i' -&gt; i'' -&gt; k</tt> and <tt>p</tt>, <tt>i -&gt; i' -&gt;
--   i'' -&gt; <a>Constraint</a></tt>.
type Ternary (a :: i -> i' -> k) (p :: i -> i' -> i'' -> Constraint) = a <| p

-- | <tt>a <tt>&lt;|</tt> p</tt>, with <tt>a</tt> being of the kind <tt>i
--   -&gt; i' -&gt; i'' -&gt; i''' -&gt; k</tt> and <tt>p</tt>, <tt>i -&gt;
--   i' -&gt; i'' -&gt; i''' -&gt; <a>Constraint</a></tt>.
type Quaternary (a :: i -> i' -> i'' -> i''' -> k) (p :: i -> i' -> i'' -> i''' -> Constraint) = a <| p

-- | <tt>a <tt>&lt;|</tt> p</tt>, with <tt>a</tt> being of the kind <tt>i
--   -&gt; i' -&gt; i'' -&gt; i''' -&gt; i'''' -&gt; k</tt> and <tt>p</tt>,
--   <tt>i -&gt; i' -&gt; i'' -&gt; i''' -&gt; i'''' -&gt;
--   <a>Constraint</a></tt>.
type Quinary (a :: i -> i' -> i'' -> i''' -> i'''' -> k) (p :: i -> i' -> i'' -> i''' -> i'''' -> Constraint) = a <| p

-- | <tt>a <tt>&lt;|</tt> p</tt>, with <tt>a</tt> being of the kind <tt>i
--   -&gt; i' -&gt; i'' -&gt; i''' -&gt; i'''' -&gt; i''''' -&gt; k</tt>
--   and <tt>p</tt>, <tt>i -&gt; i' -&gt; i'' -&gt; i''' -&gt; i'''' -&gt;
--   i''''' -&gt; <a>Constraint</a></tt>.
type Senary (a :: i -> i' -> i'' -> i''' -> i'''' -> i''''' -> k) (p :: i -> i' -> i'' -> i''' -> i'''' -> i''''' -> Constraint) = a <| p

-- | <tt><a>AllOf</a> as f</tt> is a tuple that contains values of the type
--   <tt>f a</tt>, where <tt>a</tt> can be any type that satisfies <tt>In
--   as a</tt>. Each value corresponds to each type pattern, and the values
--   in <tt><a>AllOf</a> as f</tt> must be in the same order as the type
--   patterns in <tt>as</tt>. <a>And</a>, <a>And1</a>, <a>And2</a>, ...,
--   <a>And6</a> are used to combine the values and <a>None</a> must be
--   added at the end. You have to use <a>And</a> for <tt><a>Type</a>
--   a</tt>, <a>And1</a> for <tt><a>Unary</a> a p</tt>, <a>And2</a> for
--   <tt><a>Binary</a> a p</tt>, ..., <a>And6</a> for <tt><a>Senary</a> a
--   p</tt>.
type AllOf as = AllOf' as as

-- | <a>This</a> creates a recursion. In other words, <a>This</a> will work
--   as <tt><a>In</a> as</tt> itself when used in the type list (first
--   parameter) <tt>as</tt> of <a>In</a>, combined with <a>Type</a>,
--   <tt>&lt;|</tt>, <a>Unary</a>, <a>Binary</a>, ..., <a>Senary</a>,
--   <tt>&gt;+&lt;</tt>, <tt>&gt;++&lt;</tt>, ..., <tt>&gt;++++++&lt;</tt>,
--   <tt>&gt;|&lt;</tt>, <tt>&gt;||&lt;</tt>, ..., <tt>&gt;|||||&lt;</tt>.
--   
--   Note that <a>This</a> won't be expanded into <tt><a>In</a> as</tt> if
--   the condition described above is not satisfied. Internally, the
--   expansion is executed by <a>Modify</a>, <a>Modify2</a>, ...,
--   <a>Modify6</a>.
--   
--   The instance of <a>This</a> itself can't be created since the context
--   <tt>True~False</tt> will never be satisfied.
--   
--   There is no predetermined limit of recursion depth, but GHC has a
--   fixed-depth recursion stack for safety, so you may need to increase
--   the stack depth with <tt>-fcontext-stack=N</tt>.
class True ~ False => This (a :: k)

-- | <tt><a>Pure</a> a</tt> is equivalent to the empty constraint
--   <tt>()</tt>.
--   
--   <pre>
--   Pure a == ()
--   </pre>
class Pure (a :: i)

-- | <pre>
--   (Is a) b == (a ~ b)
--   </pre>
type Is a b = a ~ b

-- | <pre>
--   (p &gt;+&lt; q) a == (p a, q a)
--   </pre>
class (p a, q a) => (>+<) p q a

-- | <pre>
--   (p &gt;++&lt; q) a b == (p a b, q a b)
--   </pre>
class (p a b, q a b) => (>++<) p q a b

-- | <pre>
--   (p &gt;+++&lt; q) a b c == (p a b c, q a b c)
--   </pre>
class (p a b c, q a b c) => (>+++<) p q a b c

-- | <pre>
--   (p &gt;++++&lt; q) a b c d == (p a b c d, q a b c d)
--   </pre>
class (p a b c d, q a b c d) => (>++++<) p q a b c d

-- | <pre>
--   (p &gt;+++++&lt; q) a b c d e == (p a b c d e, q a b c d e)
--   </pre>
class (p a b c d e, q a b c d e) => (>+++++<) p q a b c d e

-- | <pre>
--   (p &gt;++++++&lt; q) a b c d e f == (p a b c d e f, q a b c d e f)
--   </pre>
class (p a b c d e f, q a b c d e f) => (>++++++<) p q a b c d e f

-- | <pre>
--   (p &gt;|&lt; q) a b == (p a, q b)
--   </pre>
class (p a, q b) => (>|<) p q a b

-- | <pre>
--   (p &gt;||&lt; q) a b c == (p a b, q c)
--   </pre>
class (p a b, q c) => (>||<) p q a b c

-- | <pre>
--   (p &gt;|||&lt; q) a b c d == (p a b c, q d)
--   </pre>
class (p a b c, q d) => (>|||<) p q a b c d

-- | <pre>
--   (p &gt;||||&lt; q) a b c d e == (p a b c d, q e)
--   </pre>
class (p a b c d, q e) => (>||||<) p q a b c d e

-- | <pre>
--   (p &gt;|||||&lt; q) a b c d e f == (p a b c d e, q f)
--   </pre>
class (p a b c d e, q f) => (>|||||<) p q a b c d e f
type AllOfI as = AllOfI' as as
type AllOfI' ts as = AllOf' ts as Id
andI :: a -> AllOfI' ts as -> AllOfI' ts (Type a : as)
andI1 :: (forall b. Modify (In ts) p b => a b) -> AllOfI' ts as -> AllOfI' ts ((a <| p) : as)
andI2 :: (forall b c. Modify2 (In ts) p b c => a b c) -> AllOfI' ts as -> AllOfI' ts ((a <| p) : as)
andI3 :: (forall b c d. Modify3 (In ts) p b c d => a b c d) -> AllOfI' ts as -> AllOfI' ts ((a <| p) : as)
andI4 :: (forall b c d e. Modify4 (In ts) p b c d e => a b c d e) -> AllOfI' ts as -> AllOfI' ts ((a <| p) : as)
andI5 :: (forall b c d e f. Modify5 (In ts) p b c d e f => a b c d e f) -> AllOfI' ts as -> AllOfI' ts ((a <| p) : as)
andI6 :: (forall b c d e f g. Modify6 (In ts) p b c d e f g => a b c d e f g) -> AllOfI' ts as -> AllOfI' ts ((a <| p) : as)
noneI :: AllOfI' ts []
projI :: In as a => AllOfI as -> a
type AllOfF as t = AllOfF' as as t
type AllOfF' ts as t = AllOf' ts as (Func t)
andF :: (a -> t) -> AllOfF' ts as t -> AllOfF' ts (Type a : as) t
andF1 :: (forall b. Modify (In ts) p b => a b -> t) -> AllOfF' ts as t -> AllOfF' ts ((a <| p) : as) t
andF2 :: (forall b c. Modify2 (In ts) p b c => a b c -> t) -> AllOfF' ts as t -> AllOfF' ts ((a <| p) : as) t
andF3 :: (forall b c d. Modify3 (In ts) p b c d => a b c d -> t) -> AllOfF' ts as t -> AllOfF' ts ((a <| p) : as) t
andF4 :: (forall b c d e. Modify4 (In ts) p b c d e => a b c d e -> t) -> AllOfF' ts as t -> AllOfF' ts ((a <| p) : as) t
andF5 :: (forall b c d e f. Modify5 (In ts) p b c d e f => a b c d e f -> t) -> AllOfF' ts as t -> AllOfF' ts ((a <| p) : as) t
andF6 :: (forall b c d e f g. Modify6 (In ts) p b c d e f g => a b c d e f g -> t) -> AllOfF' ts as t -> AllOfF' ts ((a <| p) : as) t
noneF :: AllOfF' ts [] t
projF :: In as a => AllOfF as t -> (a -> t)
instance In' n ts as a => In' (Look_At_Tail n) ts ((b <| p) : as) a
instance In' n ts as a => In' (Look_At_Tail n) ts ((b <| p) : as) a
instance In' n ts as a => In' (Look_At_Tail n) ts ((b <| p) : as) a
instance In' n ts as a => In' (Look_At_Tail n) ts ((b <| p) : as) a
instance In' n ts as a => In' (Look_At_Tail n) ts ((b <| p) : as) a
instance In' n ts as a => In' (Look_At_Tail n) ts ((b <| p) : as) a
instance In' n ts as a => In' (Look_At_Tail n) ts (Type b : as) a
instance (Modify6 (In ts) p b c d e f g) => In' Look_At_Head ts ((a <| p) : as) (a b c d e f g)
instance (Modify5 (In ts) p b c d e f) => In' Look_At_Head ts ((a <| p) : as) (a b c d e f)
instance (Modify4 (In ts) p b c d e) => In' Look_At_Head ts ((a <| p) : as) (a b c d e)
instance (Modify3 (In ts) p b c d) => In' Look_At_Head ts ((a <| p) : as) (a b c d)
instance (Modify2 (In ts) p b c) => In' Look_At_Head ts ((a <| p) : as) (a b c)
instance (Modify (In ts) p b) => In' Look_At_Head ts ((a <| p) : as) (a b)
instance In' Look_At_Head ts (Type a : as) a
instance In' (Where as a) as as a => In as a
instance (p a b c d e, q f) => (>|||||<) p q a b c d e f
instance (p a b c d, q e) => (>||||<) p q a b c d e
instance (p a b c, q d) => (>|||<) p q a b c d
instance (p a b, q c) => (>||<) p q a b c
instance (p a, q b) => (>|<) p q a b
instance (p a b c d e f, q a b c d e f) => (>++++++<) p q a b c d e f
instance (p a b c d e, q a b c d e) => (>+++++<) p q a b c d e
instance (p a b c d, q a b c d) => (>++++<) p q a b c d
instance (p a b c, q a b c) => (>+++<) p q a b c
instance (p a b, q a b) => (>++<) p q a b
instance (p a, q a) => (>+<) p q a
instance Pure a