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


-- | Haskus data utility modules
--   
--   Haskus data utility modules
@package haskus-utils-data
@version 1.3

module Haskus.Utils.Either


-- | Functor and recursion schemes
--   
--   Simple API is intended to be easier to understand (e.g. they don't use
--   xxmorphism and xxxalgebra jargon but tree-traversal-like terms).
module Haskus.Utils.Functor
type BottomUpT a f = f a -> a

-- | Bottom-up traversal (catamorphism)
bottomUp :: Recursive t => (Base t a -> a) -> t -> a
type BottomUpOrigT t a f = f (t, a) -> a

-- | Bottom-up traversal with original value (paramorphism)
bottomUpOrig :: Recursive t => (Base t (t, a) -> a) -> t -> a
type TopDownStopT a f = f a -> Either (f a) a

-- | Perform a top-down traversal
--   
--   Right: stop the traversal ("right" value obtained) Left: continue the
--   traversal recursively on the new value
topDownStop :: (Recursive t, Corecursive t) => (Base t t -> Either (Base t t) t) -> t -> t

-- | A coeffectful version of <a>hoist</a>.
--   
--   Properties:
--   
--   <pre>
--   <a>cotransverse</a> <a>distAna</a> = <a>runIdentity</a>
--   </pre>
--   
--   Examples:
--   
--   Stateful transformations:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   cotransverse
--     (\(u, b) -&gt; case b of
--       Nil -&gt; Nil
--       Cons x a -&gt; Cons (if u then toUpper x else x) (not u, a))
--     (True, "foobar") :: String
--   :}
--   "FoObAr"
--   </pre>
--   
--   We can implement a variant of <a>zipWith</a>
--   
--   <pre>
--   &gt;&gt;&gt; data Pair a = Pair a a deriving Functor
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let zipWith' :: (a -&gt; a -&gt; b) -&gt; [a] -&gt; [a] -&gt; [b]
--       zipWith' f xs ys = cotransverse g (Pair xs ys) where
--         g (Pair Nil        _)          = Nil
--         g (Pair _          Nil)        = Nil
--         g (Pair (Cons x a) (Cons y b)) = Cons (f x y) (Pair a b)
--       :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; zipWith' (*) [1,2,3] [4,5,6]
--   [4,10,18]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; zipWith' (*) [1,2,3] [4,5,6,8]
--   [4,10,18]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; zipWith' (*) [1,2,3,3] [4,5,6]
--   [4,10,18]
--   </pre>
cotransverse :: (Recursive s, Corecursive t, Functor f) => (forall a. () => f (Base s a) -> Base t (f a)) -> f s -> t

-- | An effectful version of <a>hoist</a>.
--   
--   Properties:
--   
--   <pre>
--   <a>transverse</a> <a>sequenceA</a> = <a>pure</a>
--   </pre>
--   
--   Examples:
--   
--   The weird type of first argument allows user to decide an order of
--   sequencing:
--   
--   <pre>
--   &gt;&gt;&gt; transverse (\x -&gt; print (void x) *&gt; sequence x) "foo" :: IO String
--   Cons 'f' ()
--   Cons 'o' ()
--   Cons 'o' ()
--   Nil
--   "foo"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; transverse (\x -&gt; sequence x &lt;* print (void x)) "foo" :: IO String
--   Nil
--   Cons 'o' ()
--   Cons 'o' ()
--   Cons 'f' ()
--   "foo"
--   </pre>
transverse :: (Recursive s, Corecursive t, Functor f) => (forall a. () => Base s (f a) -> f (Base t a)) -> s -> f t

-- | Effectful <a>fold</a>.
--   
--   This is a type specialisation of <a>cata</a>.
--   
--   An example terminating a recursion immediately:
--   
--   <pre>
--   &gt;&gt;&gt; cataA (\alg -&gt; case alg of { Nil -&gt; pure (); Cons a _ -&gt; Const [a] })  "hello"
--   Const "h"
--   </pre>
cataA :: Recursive t => (Base t (f a) -> f a) -> t -> f a

-- | Zygohistomorphic prepromorphisms:
--   
--   A corrected and modernized version of
--   <a>http://www.haskell.org/haskellwiki/Zygohistomorphic_prepromorphisms</a>
zygoHistoPrepro :: (Corecursive t, Recursive t) => (Base t b -> b) -> (forall c. () => Base t c -> Base t c) -> (Base t (EnvT b (Cofree (Base t)) a) -> a) -> t -> a

-- | Elgot coalgebras:
--   <a>http://comonad.com/reader/2008/elgot-coalgebras/</a>
coelgot :: Functor f => ((a, f b) -> b) -> (a -> f a) -> a -> b

-- | Elgot algebras
elgot :: Functor f => (f a -> a) -> (b -> Either a (f b)) -> b -> a

-- | Mendler-style course-of-value iteration
mhisto :: () => (forall y. () => (y -> c) -> (y -> f y) -> f y -> c) -> Fix f -> c

-- | Mendler-style iteration
mcata :: () => (forall y. () => (y -> c) -> f y -> c) -> Fix f -> c
gchrono :: (Functor f, Functor w, Functor m, Comonad w, Monad m) => (forall c. () => f (w c) -> w (f c)) -> (forall c. () => m (f c) -> f (m c)) -> (f (CofreeT f w b) -> b) -> (a -> f (FreeT f m a)) -> a -> b
chrono :: Functor f => (f (Cofree f b) -> b) -> (a -> f (Free f a)) -> a -> b
distGHisto :: (Functor f, Functor h) => (forall b. () => f (h b) -> h (f b)) -> f (CofreeT f h a) -> CofreeT f h (f a)
distHisto :: Functor f => f (Cofree f a) -> Cofree f (f a)
ghisto :: (Recursive t, Comonad w) => (forall b. () => Base t (w b) -> w (Base t b)) -> (Base t (CofreeT (Base t) w a) -> a) -> t -> a

-- | Course-of-value iteration
histo :: Recursive t => (Base t (Cofree (Base t) a) -> a) -> t -> a
distGApoT :: (Functor f, Functor m) => (b -> f b) -> (forall c. () => m (f c) -> f (m c)) -> ExceptT b m (f a) -> f (ExceptT b m a)
distGApo :: Functor f => (b -> f b) -> Either b (f a) -> f (Either b a)
distApo :: Recursive t => Either t (Base t a) -> Base t (Either t a)
gapo :: Corecursive t => (b -> Base t b) -> (a -> Base t (Either b a)) -> a -> t
distZygoT :: (Functor f, Comonad w) => (f b -> b) -> (forall c. () => f (w c) -> w (f c)) -> f (EnvT b w a) -> EnvT b w (f a)
gzygo :: (Recursive t, Comonad w) => (Base t b -> b) -> (forall c. () => Base t (w c) -> w (Base t c)) -> (Base t (EnvT b w a) -> a) -> t -> a
distZygo :: Functor f => (f b -> b) -> f (b, a) -> (b, f a)
zygo :: Recursive t => (Base t b -> b) -> (Base t (b, a) -> a) -> t -> a

-- | A specialized, faster version of <a>hoist</a> for <a>Nu</a>.
hoistNu :: () => (forall a. () => f a -> g a) -> Nu f -> Nu g

-- | A specialized, faster version of <a>hoist</a> for <a>Mu</a>.
hoistMu :: () => (forall a. () => f a -> g a) -> Mu f -> Mu g
refix :: (Recursive s, Corecursive t, Base s ~ Base t) => s -> t
hoist :: (Recursive s, Corecursive t) => (forall a. () => Base s a -> Base t a) -> s -> t
unfix :: () => Fix f -> f (Fix f)
distGFutu :: (Functor f, Functor h) => (forall b. () => h (f b) -> f (h b)) -> FreeT f h (f a) -> f (FreeT f h a)
distFutu :: Functor f => Free f (f a) -> f (Free f a)
gfutu :: (Corecursive t, Functor m, Monad m) => (forall b. () => m (Base t b) -> Base t (m b)) -> (a -> Base t (FreeT (Base t) m a)) -> a -> t
futu :: Corecursive t => (a -> Base t (Free (Base t) a)) -> a -> t

-- | A generalized hylomorphism
grefold :: (Comonad w, Functor f, Monad m) => (forall c. () => f (w c) -> w (f c)) -> (forall d. () => m (f d) -> f (m d)) -> (f (w b) -> b) -> (a -> f (m a)) -> a -> b

-- | A generalized hylomorphism
ghylo :: (Comonad w, Functor f, Monad m) => (forall c. () => f (w c) -> w (f c)) -> (forall d. () => m (f d) -> f (m d)) -> (f (w b) -> b) -> (a -> f (m a)) -> a -> b
distAna :: Functor f => Identity (f a) -> f (Identity a)

-- | A generalized anamorphism
gunfold :: (Corecursive t, Monad m) => (forall b. () => m (Base t b) -> Base t (m b)) -> (a -> Base t (m a)) -> a -> t

-- | A generalized anamorphism
gana :: (Corecursive t, Monad m) => (forall b. () => m (Base t b) -> Base t (m b)) -> (a -> Base t (m a)) -> a -> t
distCata :: Functor f => f (Identity a) -> Identity (f a)

-- | A generalized catamorphism
gfold :: (Recursive t, Comonad w) => (forall b. () => Base t (w b) -> w (Base t b)) -> (Base t (w a) -> a) -> t -> a

-- | A generalized catamorphism
gcata :: (Recursive t, Comonad w) => (forall b. () => Base t (w b) -> w (Base t b)) -> (Base t (w a) -> a) -> t -> a
refold :: Functor f => (f b -> b) -> (a -> f a) -> a -> b
unfold :: Corecursive t => (a -> Base t a) -> a -> t
fold :: Recursive t => (Base t a -> a) -> t -> a
hylo :: Functor f => (f b -> b) -> (a -> f a) -> a -> b
distParaT :: (Corecursive t, Comonad w) => (forall b. () => Base t (w b) -> w (Base t b)) -> Base t (EnvT t w a) -> EnvT t w (Base t a)
distPara :: Corecursive t => Base t (t, a) -> (t, Base t a)
type family Base t :: Type -> Type
class Functor Base t => Recursive t
project :: Recursive t => t -> Base t t
cata :: Recursive t => (Base t a -> a) -> t -> a
para :: Recursive t => (Base t (t, a) -> a) -> t -> a
gpara :: (Recursive t, Corecursive t, Comonad w) => (forall b. () => Base t (w b) -> w (Base t b)) -> (Base t (EnvT t w a) -> a) -> t -> a

-- | Fokkinga's prepromorphism
prepro :: (Recursive t, Corecursive t) => (forall b. () => Base t b -> Base t b) -> (Base t a -> a) -> t -> a
gprepro :: (Recursive t, Corecursive t, Comonad w) => (forall b. () => Base t (w b) -> w (Base t b)) -> (forall c. () => Base t c -> Base t c) -> (Base t (w a) -> a) -> t -> a
class Functor Base t => Corecursive t
embed :: Corecursive t => Base t t -> t
ana :: Corecursive t => (a -> Base t a) -> a -> t
apo :: Corecursive t => (a -> Base t (Either t a)) -> a -> t

-- | Fokkinga's postpromorphism
postpro :: (Corecursive t, Recursive t) => (forall b. () => Base t b -> Base t b) -> (a -> Base t a) -> a -> t

-- | A generalized postpromorphism
gpostpro :: (Corecursive t, Recursive t, Monad m) => (forall b. () => m (Base t b) -> Base t (m b)) -> (forall c. () => Base t c -> Base t c) -> (a -> Base t (m a)) -> a -> t
newtype Fix (f :: Type -> Type)
Fix :: f (Fix f) -> Fix
newtype Mu (f :: Type -> Type)
Mu :: (forall a. () => (f a -> a) -> a) -> Mu
data Nu (f :: Type -> Type)
[Nu] :: forall (f :: Type -> Type) a. () => (a -> f a) -> a -> Nu f
type Algebra f a = f a -> a
type CoAlgebra f a = a -> f a
type RAlgebra f t a = f (t, a) -> a
type RCoAlgebra f t a = a -> f (Either t a)
type f ~> g = forall a. f a -> g a
type NatM m f g = forall a. f a -> m (g a)
type family HBase (h :: k -> Type) :: (k -> Type) -> (k -> Type)
type HAlgebra h f = h f ~> f
type HAlgebraM m h f = NatM m (h f) f
type HGAlgebra w h a = h (w a) ~> a
type HGAlgebraM w m h a = NatM m (h (w a)) a
type HCoalgebra h f = f ~> h f
type HCoalgebraM m h f = NatM m f (h f)
type HGCoalgebra m h a = a ~> h (m a)
type HGCoalgebraM n m h a = NatM m a (h (n a))
class HFunctor (h :: (k -> Type) -> (k -> Type))
hfmap :: HFunctor h => (f ~> g) -> h f ~> h g
class HFunctor h => HFoldable (h :: (k -> Type) -> (k -> Type))
hfoldMap :: (HFoldable h, Monoid m) => (forall b. f b -> m) -> h f a -> m
class HFoldable h => HTraversable (h :: (k -> Type) -> (k -> Type))
htraverse :: (HTraversable h, Applicative e) => NatM e f g -> NatM e (h f) (h g)
class HFunctor (HBase h) => HRecursive (h :: k -> Type)
hproject :: HRecursive h => HCoalgebra (HBase h) h
hcata :: HRecursive h => HAlgebra (HBase h) f -> h ~> f
class HFunctor (HBase h) => HCorecursive (h :: k -> Type)
hembed :: HCorecursive h => HAlgebra (HBase h) h
hana :: HCorecursive h => HCoalgebra (HBase h) f -> f ~> h
hhylo :: HFunctor f => HAlgebra f b -> HCoalgebra f a -> a ~> b
hcataM :: (Monad m, HTraversable (HBase h), HRecursive h) => HAlgebraM m (HBase h) f -> h a -> m (f a)
hlambek :: (HRecursive h, HCorecursive h) => HCoalgebra (HBase h) h
hpara :: (HFunctor (HBase h), HRecursive h) => HGAlgebra (Product h) (HBase h) a -> h ~> a
hparaM :: (HTraversable (HBase h), HRecursive h, Monad m) => HGAlgebraM (Product h) m (HBase h) a -> NatM m h a
hanaM :: (Monad m, HTraversable (HBase h), HCorecursive h) => HCoalgebraM m (HBase h) f -> f a -> m (h a)
hcolambek :: HRecursive h => HCorecursive h => HAlgebra (HBase h) h
hapo :: HCorecursive h => HGCoalgebra (Sum h) (HBase h) a -> a ~> h
hapoM :: (HCorecursive h, HTraversable (HBase h), Monad m) => HGCoalgebraM (Sum h) m (HBase h) a -> NatM m a h
hhyloM :: (HTraversable t, Monad m) => HAlgebraM m t h -> HCoalgebraM m t f -> f a -> m (h a)


-- | Infinite list
module Haskus.Utils.InfList

-- | An infinite list
data InfList a
(:>) :: a -> InfList a -> InfList a

-- | Convert to a standard list
toList :: InfList a -> [a]

-- | Repeat for infinite list
repeat :: a -> InfList a

-- | Take for infinite list
take :: Word -> InfList a -> [a]

-- | Replicate for infinite list
replicate :: Word -> a -> InfList a -> InfList a
instance Data.Foldable.Foldable Haskus.Utils.InfList.InfList
instance GHC.Base.Functor Haskus.Utils.InfList.InfList


-- | List utils
module Haskus.Utils.List

-- | Safely index into a list
--   
--   <pre>
--   &gt;&gt;&gt; [0,1,2,3] `at` 10
--   Nothing
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; [0,1,2,3] `at` 2
--   Just 2
--   </pre>
at :: [a] -> Word -> Maybe a

-- | Unsafe <tt>a</tt>
--   
--   <pre>
--   &gt;&gt;&gt; [0,1,2,3] `unsafeAt` 2
--   2
--   </pre>
unsafeAt :: [a] -> Word -> a

-- | Check that a list has the given length (support infinite lists)
checkLength :: Word -> [a] -> Bool

-- | Append two lists, i.e.,
--   
--   <pre>
--   [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
--   [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
--   </pre>
--   
--   If the first list is not finite, the result is the first list.
(++) :: () => [a] -> [a] -> [a]
infixr 5 ++

-- | Replicate
replicate :: Word -> a -> [a]

-- | Drop
drop :: Word -> [a] -> [a]

-- | Length
length :: Foldable t => t a -> Word

-- | Take
take :: Word -> [a] -> [a]

-- | Split a list into chunks of a given size. The last chunk may contain
--   fewer than n elements.
--   
--   <pre>
--   &gt;&gt;&gt; chunksOf 3 "my test"
--   ["my ","tes","t"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; chunksOf 3 "mytest"
--   ["myt","est"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; chunksOf 8 ""
--   []
--   </pre>
--   
--   <pre>
--   &gt; chunksOf 0 "test"
--   </pre>
--   
--   undefined
chunksOf :: Word -> [a] -> [[a]]

-- | Pick each element and return the element and the rest of the list
--   
--   <pre>
--   &gt;&gt;&gt; pick1 [1,2,3,4]
--   [(1,[2,3,4]),(2,[1,3,4]),(3,[1,2,4]),(4,[1,2,3])]
--   </pre>
pick1 :: [a] -> [(a, [a])]

-- | Get members of a bounded enum in a list
--   
--   <pre>
--   &gt;&gt;&gt; :set -XTypeApplications
--   
--   &gt;&gt;&gt; data Letters = A | B | C | D deriving (Bounded,Enum,Show)
--   
--   &gt;&gt;&gt; enumList @Letters
--   [A,B,C,D]
--   </pre>
enumList :: forall a. (Bounded a, Enum a) => [a]

-- | Zip left with something extracted from each value
--   
--   <pre>
--   &gt;&gt;&gt; zipLeftWith odd [0..5]
--   [(False,0),(True,1),(False,2),(True,3),(False,4),(True,5)]
--   </pre>
zipLeftWith :: (a -> b) -> [a] -> [(b, a)]

-- | Zip right with something extracted from each value
--   
--   <pre>
--   &gt;&gt;&gt; zipRightWith odd [0..5]
--   [(0,False),(1,True),(2,False),(3,True),(4,False),(5,True)]
--   </pre>
zipRightWith :: (a -> b) -> [a] -> [(a, b)]

-- | The <a>partition</a> function takes a predicate a list and returns the
--   pair of lists of elements which do and do not satisfy the predicate,
--   respectively; i.e.,
--   
--   <pre>
--   partition p xs == (filter p xs, filter (not . p) xs)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; partition (`elem` "aeiou") "Hello World!"
--   ("eoo","Hll Wrld!")
--   </pre>
partition :: () => (a -> Bool) -> [a] -> ([a], [a])

-- | <i>O(n^2)</i>. The <a>nub</a> function removes duplicate elements from
--   a list. In particular, it keeps only the first occurrence of each
--   element. (The name <a>nub</a> means `essence'.) It is a special case
--   of <a>nubBy</a>, which allows the programmer to supply their own
--   equality test.
--   
--   <pre>
--   &gt;&gt;&gt; nub [1,2,3,4,3,2,1,2,4,3,5]
--   [1,2,3,4,5]
--   </pre>
nub :: Eq a => [a] -> [a]

-- | The <a>sort</a> function implements a stable sorting algorithm. It is
--   a special case of <a>sortBy</a>, which allows the programmer to supply
--   their own comparison function.
--   
--   Elements are arranged from from lowest to highest, keeping duplicates
--   in the order they appeared in the input.
--   
--   <pre>
--   &gt;&gt;&gt; sort [1,6,4,3,2,5]
--   [1,2,3,4,5,6]
--   </pre>
sort :: Ord a => [a] -> [a]

-- | The <a>intersperse</a> function takes an element and a list and
--   `intersperses' that element between the elements of the list. For
--   example,
--   
--   <pre>
--   &gt;&gt;&gt; intersperse ',' "abcde"
--   "a,b,c,d,e"
--   </pre>
intersperse :: () => a -> [a] -> [a]

-- | Left-associative fold of a structure but with strict application of
--   the operator.
--   
--   This ensures that each step of the fold is forced to weak head normal
--   form before being applied, avoiding the collection of thunks that
--   would otherwise occur. This is often what you want to strictly reduce
--   a finite list to a single, monolithic result (e.g. <a>length</a>).
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldl f z = <a>foldl'</a> f z . <a>toList</a>
--   </pre>
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b

-- | Extract the first element of a list, which must be non-empty.
head :: () => [a] -> a

-- | Extract the elements after the head of a list, which must be
--   non-empty.
tail :: () => [a] -> [a]

-- | <a>zipWith</a> generalises <a>zip</a> by zipping with the function
--   given as the first argument, instead of a tupling function. For
--   example, <tt><a>zipWith</a> (+)</tt> is applied to two lists to
--   produce the list of corresponding sums.
--   
--   <a>zipWith</a> is right-lazy:
--   
--   <pre>
--   zipWith f [] _|_ = []
--   </pre>
zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]

-- | <a>repeat</a> <tt>x</tt> is an infinite list, with <tt>x</tt> the
--   value of every element.
repeat :: () => a -> [a]

-- | A version of <tt>nub</tt> where the equality is done on some extracted
--   value. <tt>nubOn f</tt> is equivalent to <tt>nubBy ((==) <a>on</a>
--   f)</tt>, but has the performance advantage of only evaluating
--   <tt>f</tt> once for each element in the input list.
nubOn :: Eq b => (a -> b) -> [a] -> [a]

-- | The <a>nubBy</a> function behaves just like <a>nub</a>, except it uses
--   a user-supplied equality predicate instead of the overloaded <a>==</a>
--   function.
--   
--   <pre>
--   &gt;&gt;&gt; nubBy (\x y -&gt; mod x 3 == mod y 3) [1,2,4,5,6]
--   [1,2,6]
--   </pre>
nubBy :: () => (a -> a -> Bool) -> [a] -> [a]

-- | Sort a list by comparing the results of a key function applied to each
--   element. <tt>sortOn f</tt> is equivalent to <tt>sortBy (comparing
--   f)</tt>, but has the performance advantage of only evaluating
--   <tt>f</tt> once for each element in the input list. This is called the
--   decorate-sort-undecorate paradigm, or Schwartzian transform.
--   
--   Elements are arranged from from lowest to highest, keeping duplicates
--   in the order they appeared in the input.
--   
--   <pre>
--   &gt;&gt;&gt; sortOn fst [(2, "world"), (4, "!"), (1, "Hello")]
--   [(1,"Hello"),(2,"world"),(4,"!")]
--   </pre>
sortOn :: Ord b => (a -> b) -> [a] -> [a]

-- | The <a>sortBy</a> function is the non-overloaded version of
--   <a>sort</a>.
--   
--   <pre>
--   &gt;&gt;&gt; sortBy (\(a,_) (b,_) -&gt; compare a b) [(2, "world"), (4, "!"), (1, "Hello")]
--   [(1,"Hello"),(2,"world"),(4,"!")]
--   </pre>
sortBy :: () => (a -> a -> Ordering) -> [a] -> [a]

-- | A version of <tt>group</tt> where the equality is done on some
--   extracted value.
groupOn :: Eq b => (a -> b) -> [a] -> [[a]]

-- | The <a>groupBy</a> function is the non-overloaded version of
--   <a>group</a>.
groupBy :: () => (a -> a -> Bool) -> [a] -> [[a]]

-- | The <a>transpose</a> function transposes the rows and columns of its
--   argument. For example,
--   
--   <pre>
--   &gt;&gt;&gt; transpose [[1,2,3],[4,5,6]]
--   [[1,4],[2,5],[3,6]]
--   </pre>
--   
--   If some of the rows are shorter than the following rows, their
--   elements are skipped:
--   
--   <pre>
--   &gt;&gt;&gt; transpose [[10,11],[20],[],[30,31,32]]
--   [[10,20,30],[11,31],[32]]
--   </pre>
transpose :: () => [[a]] -> [[a]]

-- | The <a>\\</a> function is list difference (non-associative). In the
--   result of <tt>xs</tt> <a>\\</a> <tt>ys</tt>, the first occurrence of
--   each element of <tt>ys</tt> in turn (if any) has been removed from
--   <tt>xs</tt>. Thus
--   
--   <pre>
--   (xs ++ ys) \\ xs == ys.
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello World!" \\ "ell W"
--   "Hoorld!"
--   </pre>
--   
--   It is a special case of <a>deleteFirstsBy</a>, which allows the
--   programmer to supply their own equality test.
(\\) :: Eq a => [a] -> [a] -> [a]
infix 5 \\

-- | The <a>intersect</a> function takes the list intersection of two
--   lists. For example,
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,3,4] `intersect` [2,4,6,8]
--   [2,4]
--   </pre>
--   
--   If the first list contains duplicates, so will the result.
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,2,3,4] `intersect` [6,4,4,2]
--   [2,2,4]
--   </pre>
--   
--   It is a special case of <a>intersectBy</a>, which allows the
--   programmer to supply their own equality test. If the element is found
--   in both the first and the second list, the element from the first list
--   will be used.
intersect :: Eq a => [a] -> [a] -> [a]

-- | The <a>find</a> function takes a predicate and a structure and returns
--   the leftmost element of the structure matching the predicate, or
--   <a>Nothing</a> if there is no such element.
find :: Foldable t => (a -> Bool) -> t a -> Maybe a

-- | <a>zip3</a> takes three lists and returns a list of triples, analogous
--   to <a>zip</a>.
zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]

-- | The <a>zip4</a> function takes four lists and returns a list of
--   quadruples, analogous to <a>zip</a>.
zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]

-- | The <a>zip5</a> function takes five lists and returns a list of
--   five-tuples, analogous to <a>zip</a>.
zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]

-- | The <a>zip6</a> function takes six lists and returns a list of
--   six-tuples, analogous to <a>zip</a>.
zip6 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]

-- | The <a>zip7</a> function takes seven lists and returns a list of
--   seven-tuples, analogous to <a>zip</a>.
zip7 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]

-- | The <a>stripPrefix</a> function drops the given prefix from a list. It
--   returns <a>Nothing</a> if the list did not start with the prefix
--   given, or <a>Just</a> the list after the prefix, if it does.
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "foobar"
--   Just "bar"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "foo"
--   Just ""
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "barfoo"
--   Nothing
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "barfoobaz"
--   Nothing
--   </pre>
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]

-- | The <a>isPrefixOf</a> function takes two lists and returns <a>True</a>
--   iff the first list is a prefix of the second.
--   
--   <pre>
--   &gt;&gt;&gt; "Hello" `isPrefixOf` "Hello World!"
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello" `isPrefixOf` "Wello Horld!"
--   False
--   </pre>
isPrefixOf :: Eq a => [a] -> [a] -> Bool

-- | The <a>deleteBy</a> function behaves like <a>delete</a>, but takes a
--   user-supplied equality predicate.
--   
--   <pre>
--   &gt;&gt;&gt; deleteBy (&lt;=) 4 [1..10]
--   [1,2,3,5,6,7,8,9,10]
--   </pre>
deleteBy :: () => (a -> a -> Bool) -> a -> [a] -> [a]

-- | The <a>isSuffixOf</a> function takes two lists and returns <a>True</a>
--   iff the first list is a suffix of the second. The second list must be
--   finite.
--   
--   <pre>
--   &gt;&gt;&gt; "ld!" `isSuffixOf` "Hello World!"
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "World" `isSuffixOf` "Hello World!"
--   False
--   </pre>
isSuffixOf :: Eq a => [a] -> [a] -> Bool

-- | Does the element occur in the structure?
elem :: (Foldable t, Eq a) => a -> t a -> Bool
infix 4 `elem`

-- | <a>notElem</a> is the negation of <a>elem</a>.
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
infix 4 `notElem`

-- | <a>splitAt</a> <tt>n xs</tt> returns a tuple where first element is
--   <tt>xs</tt> prefix of length <tt>n</tt> and second element is the
--   remainder of the list:
--   
--   <pre>
--   splitAt 6 "Hello World!" == ("Hello ","World!")
--   splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
--   splitAt 1 [1,2,3] == ([1],[2,3])
--   splitAt 3 [1,2,3] == ([1,2,3],[])
--   splitAt 4 [1,2,3] == ([1,2,3],[])
--   splitAt 0 [1,2,3] == ([],[1,2,3])
--   splitAt (-1) [1,2,3] == ([],[1,2,3])
--   </pre>
--   
--   It is equivalent to <tt>(<a>take</a> n xs, <a>drop</a> n xs)</tt> when
--   <tt>n</tt> is not <tt>_|_</tt> (<tt>splitAt _|_ xs = _|_</tt>).
splitAt :: Integral n => n -> [a] -> ([a], [a])

-- | Splits a list into components delimited by separators, where the
--   predicate returns True for a separator element. The resulting
--   components do not contain the separators. Two adjacent separators
--   result in an empty component in the output.
--   
--   <pre>
--   split (== 'a') "aabbaca" == ["","","bb","c",""]
--   split (== 'a') ""        == [""]
--   split (== ':') "::xyz:abc::123::" == ["","","xyz","abc","","123","",""]
--   split (== ',') "my,list,here" == ["my","list","here"]
--   </pre>
split :: (a -> Bool) -> [a] -> [[a]]

-- | Break a list into pieces separated by the first list argument,
--   consuming the delimiter. An empty delimiter is invalid, and will cause
--   an error to be raised.
--   
--   <pre>
--   splitOn "\r\n" "a\r\nb\r\nd\r\ne" == ["a","b","d","e"]
--   splitOn "aaa"  "aaaXaaaXaaaXaaa"  == ["","X","X","X",""]
--   splitOn "x"    "x"                == ["",""]
--   splitOn "x"    ""                 == [""]
--   \s x -&gt; s /= "" ==&gt; intercalate s (splitOn s x) == x
--   \c x -&gt; splitOn [c] x                           == split (==c) x
--   </pre>
splitOn :: Eq a => [a] -> [a] -> [[a]]

-- | Find the first instance of <tt>needle</tt> in <tt>haystack</tt>. The
--   first element of the returned tuple is the prefix of <tt>haystack</tt>
--   before <tt>needle</tt> is matched. The second is the remainder of
--   <tt>haystack</tt>, starting with the match. If you want the remainder
--   <i>without</i> the match, use <tt>stripInfix</tt>.
--   
--   <pre>
--   breakOn "::" "a::b::c" == ("a", "::b::c")
--   breakOn "/" "foobar"   == ("foobar", "")
--   \needle haystack -&gt; let (prefix,match) = breakOn needle haystack in prefix ++ match == haystack
--   </pre>
breakOn :: Eq a => [a] -> [a] -> ([a], [a])

module Haskus.Utils.Map

module Haskus.Utils.Map.Strict


-- | Utils for Maybe data type
module Haskus.Utils.Maybe

-- | Flipped <a>fromMaybe</a>
onNothing :: Maybe a -> a -> a

-- | Flipped <a>fromMaybeM</a>
onNothingM :: Monad m => m (Maybe a) -> m a -> m a

-- | fromMaybe in a Monad
fromMaybeM :: Monad m => m a -> m (Maybe a) -> m a

-- | Get the head of the list if the latter is not empty
headMaybe :: [a] -> Maybe a


-- | Utils for Monads
module Haskus.Utils.Monad
class MonadIO m => MonadInIO m

-- | Lift with*-like functions into IO (alloca, etc.)
liftWith :: MonadInIO m => (forall c. (a -> IO c) -> IO c) -> (a -> m b) -> m b

-- | Lift with*-like functions into IO (alloca, etc.)
liftWith2 :: MonadInIO m => (forall c. (a -> b -> IO c) -> IO c) -> (a -> b -> m e) -> m e

-- | Keep running an operation until it becomes <a>False</a>. As an
--   example:
--   
--   <pre>
--   whileM $ do sleep 0.1; notM $ doesFileExist "foo.txt"
--   readFile "foo.txt"
--   </pre>
--   
--   If you need some state persisted between each test, use <a>loopM</a>.
whileM :: Monad m => m Bool -> m ()

-- | A looping operation, where the predicate returns <a>Left</a> as a seed
--   for the next loop or <a>Right</a> to abort the loop.
--   
--   <pre>
--   loop (\x -&gt; if x &lt; 10 then Left $ x * 2 else Right $ show x) 1 == "16"
--   </pre>
loop :: (a -> Either a b) -> a -> b

-- | A monadic version of <a>loop</a>, where the predicate returns
--   <a>Left</a> as a seed for the next loop or <a>Right</a> to abort the
--   loop.
loopM :: Monad m => (a -> m (Either a b)) -> a -> m b

-- | Like <a>when</a>, but where the test can be monadic.
whenM :: Monad m => m Bool -> m () -> m ()

-- | Like <a>unless</a>, but where the test can be monadic.
unlessM :: Monad m => m Bool -> m () -> m ()

-- | Like <tt>if</tt>, but where the test can be monadic.
ifM :: Monad m => m Bool -> m a -> m a -> m a

-- | Like <a>not</a>, but where the test can be monadic.
notM :: Functor m => m Bool -> m Bool

-- | A version of <a>any</a> lifted to a monad. Retains the
--   short-circuiting behaviour.
--   
--   <pre>
--   anyM Just [False,True ,undefined] == Just True
--   anyM Just [False,False,undefined] == undefined
--   \(f :: Int -&gt; Maybe Bool) xs -&gt; anyM f xs == orM (map f xs)
--   </pre>
anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool

-- | A version of <a>all</a> lifted to a monad. Retains the
--   short-circuiting behaviour.
--   
--   <pre>
--   allM Just [True,False,undefined] == Just False
--   allM Just [True,True ,undefined] == undefined
--   \(f :: Int -&gt; Maybe Bool) xs -&gt; anyM f xs == orM (map f xs)
--   </pre>
allM :: Monad m => (a -> m Bool) -> [a] -> m Bool

-- | A version of <a>or</a> lifted to a monad. Retains the short-circuiting
--   behaviour.
--   
--   <pre>
--   orM [Just False,Just True ,undefined] == Just True
--   orM [Just False,Just False,undefined] == undefined
--   \xs -&gt; Just (or xs) == orM (map Just xs)
--   </pre>
orM :: Monad m => [m Bool] -> m Bool

-- | A version of <a>and</a> lifted to a monad. Retains the
--   short-circuiting behaviour.
--   
--   <pre>
--   andM [Just True,Just False,undefined] == Just False
--   andM [Just True,Just True ,undefined] == undefined
--   \xs -&gt; Just (and xs) == andM (map Just xs)
--   </pre>
andM :: Monad m => [m Bool] -> m Bool
instance Haskus.Utils.Monad.MonadInIO GHC.Types.IO
instance Haskus.Utils.Monad.MonadInIO m => Haskus.Utils.Monad.MonadInIO (Control.Monad.Trans.State.Lazy.StateT s m)


-- | Tuple helpers
module Haskus.Utils.Tuple

-- | Uncurry3
uncurry3 :: (a -> b -> c -> r) -> (a, b, c) -> r

-- | Uncurry4
uncurry4 :: (a -> b -> c -> d -> r) -> (a, b, c, d) -> r

-- | Uncurry5
uncurry5 :: (a -> b -> c -> d -> e -> r) -> (a, b, c, d, e) -> r

-- | Uncurry6
uncurry6 :: (a -> b -> c -> d -> e -> f -> r) -> (a, b, c, d, e, f) -> r

-- | Uncurry7
uncurry7 :: (a -> b -> c -> d -> e -> f -> g -> r) -> (a, b, c, d, e, f, g) -> r

-- | Take specialised for quadruple
take4 :: [a] -> (a, a, a, a)

-- | toList for quadruple
fromTuple4 :: (a, a, a, a) -> [a]
data Unit a
Unit :: a -> Unit a

-- | Boxed tuple
--   
--   TODO: put this family into GHC
type family Tuple xs = t | t -> xs

-- | Unboxed tuple
--   
--   TODO: put this family into GHC
type family Tuple# xs = (t :: TYPE ( 'TupleRep (TypeReps xs))) | t -> xs
type family TypeReps xs

-- | Extract a tuple value statically
class ExtractTuple (n :: Nat) xs

-- | Extract a tuple value by type-level index
tupleN :: ExtractTuple n xs => Tuple xs -> Index n xs

-- | Create a Tuple
class TupleCon xs

-- | Create a Tuple
tupleCon :: TupleCon xs => TupleFun (Tuple xs) xs

-- | Get first element of the tuple
tupleHead :: forall xs. ExtractTuple 0 xs => Tuple xs -> Index 0 xs
class TupleTail ts ts' | ts -> ts'
tupleTail :: TupleTail ts ts' => ts -> ts'
class TupleCons t ts ts' | t ts -> ts'
tupleCons :: TupleCons t ts ts' => t -> ts -> ts'

-- | Reorder tuple elements
class ReorderTuple t1 t2

-- | Reorder tuple elements
tupleReorder :: ReorderTuple t1 t2 => t1 -> t2
instance Haskus.Utils.Tuple.ExtractTuple 0 '[a]
instance Haskus.Utils.Tuple.ExtractTuple 0 '[e0, e1]
instance Haskus.Utils.Tuple.ExtractTuple 1 '[e0, e1]
instance Haskus.Utils.Tuple.ExtractTuple 0 '[e0, e1, e2]
instance Haskus.Utils.Tuple.ExtractTuple 1 '[e0, e1, e2]
instance Haskus.Utils.Tuple.ExtractTuple 2 '[e0, e1, e2]
instance Haskus.Utils.Tuple.ExtractTuple 0 '[e0, e1, e2, e3]
instance Haskus.Utils.Tuple.ExtractTuple 1 '[e0, e1, e2, e3]
instance Haskus.Utils.Tuple.ExtractTuple 2 '[e0, e1, e2, e3]
instance Haskus.Utils.Tuple.ExtractTuple 3 '[e0, e1, e2, e3]
instance Haskus.Utils.Tuple.ExtractTuple 0 '[e0, e1, e2, e3, e4]
instance Haskus.Utils.Tuple.ExtractTuple 1 '[e0, e1, e2, e3, e4]
instance Haskus.Utils.Tuple.ExtractTuple 2 '[e0, e1, e2, e3, e4]
instance Haskus.Utils.Tuple.ExtractTuple 3 '[e0, e1, e2, e3, e4]
instance Haskus.Utils.Tuple.ExtractTuple 4 '[e0, e1, e2, e3, e4]
instance Haskus.Utils.Tuple.ExtractTuple 0 '[e0, e1, e2, e3, e4, e5]
instance Haskus.Utils.Tuple.ExtractTuple 1 '[e0, e1, e2, e3, e4, e5]
instance Haskus.Utils.Tuple.ExtractTuple 2 '[e0, e1, e2, e3, e4, e5]
instance Haskus.Utils.Tuple.ExtractTuple 3 '[e0, e1, e2, e3, e4, e5]
instance Haskus.Utils.Tuple.ExtractTuple 4 '[e0, e1, e2, e3, e4, e5]
instance Haskus.Utils.Tuple.ExtractTuple 5 '[e0, e1, e2, e3, e4, e5]
instance Haskus.Utils.Tuple.ExtractTuple 0 '[e0, e1, e2, e3, e4, e5, e6]
instance Haskus.Utils.Tuple.ExtractTuple 1 '[e0, e1, e2, e3, e4, e5, e6]
instance Haskus.Utils.Tuple.ExtractTuple 2 '[e0, e1, e2, e3, e4, e5, e6]
instance Haskus.Utils.Tuple.ExtractTuple 3 '[e0, e1, e2, e3, e4, e5, e6]
instance Haskus.Utils.Tuple.ExtractTuple 4 '[e0, e1, e2, e3, e4, e5, e6]
instance Haskus.Utils.Tuple.ExtractTuple 5 '[e0, e1, e2, e3, e4, e5, e6]
instance Haskus.Utils.Tuple.ExtractTuple 6 '[e0, e1, e2, e3, e4, e5, e6]
instance Haskus.Utils.Tuple.ExtractTuple 0 '[e0, e1, e2, e3, e4, e5, e6, e7]
instance Haskus.Utils.Tuple.ExtractTuple 1 '[e0, e1, e2, e3, e4, e5, e6, e7]
instance Haskus.Utils.Tuple.ExtractTuple 2 '[e0, e1, e2, e3, e4, e5, e6, e7]
instance Haskus.Utils.Tuple.ExtractTuple 3 '[e0, e1, e2, e3, e4, e5, e6, e7]
instance Haskus.Utils.Tuple.ExtractTuple 4 '[e0, e1, e2, e3, e4, e5, e6, e7]
instance Haskus.Utils.Tuple.ExtractTuple 5 '[e0, e1, e2, e3, e4, e5, e6, e7]
instance Haskus.Utils.Tuple.ExtractTuple 6 '[e0, e1, e2, e3, e4, e5, e6, e7]
instance Haskus.Utils.Tuple.ExtractTuple 7 '[e0, e1, e2, e3, e4, e5, e6, e7]
instance Haskus.Utils.Tuple.TupleCon '[]
instance Haskus.Utils.Tuple.TupleCon '[a]
instance Haskus.Utils.Tuple.TupleCon '[a, b]
instance Haskus.Utils.Tuple.TupleCon '[a, b, c]
instance Haskus.Utils.Tuple.TupleCon '[a, b, c, d]
instance Haskus.Utils.Tuple.TupleCon '[a, b, c, d, e]
instance Haskus.Utils.Tuple.TupleCon '[a, b, c, d, e, f]
instance Haskus.Utils.Tuple.ReorderTuple (GHC.Tuple.Unit a) (GHC.Tuple.Unit a)
instance Haskus.Utils.Tuple.ReorderTuple (a, b) (a, b)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c) (a, b, c)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d) (a, b, c, d)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e) (a, b, c, d, e)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f) (a, b, c, d, e, f)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g) (a, b, c, d, e, f, g)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i, j)
instance Haskus.Utils.Tuple.ReorderTuple (a, b) (b, a)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c) (a, c, b)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c) (b, a, c)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c) (b, c, a)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c) (c, a, b)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c) (c, b, a)
instance Haskus.Utils.Tuple.ReorderTuple (b, c, d) (x, y, z) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d) (a, x, y, z)
instance Haskus.Utils.Tuple.ReorderTuple (a, c, d) (x, y, z) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d) (x, b, y, z)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, d) (x, y, z) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d) (x, y, c, z)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c) (x, y, z) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d) (x, y, z, d)
instance Haskus.Utils.Tuple.ReorderTuple (b, c, d, e) (x, y, z, w) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e) (a, x, y, z, w)
instance Haskus.Utils.Tuple.ReorderTuple (a, c, d, e) (x, y, z, w) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e) (x, b, y, z, w)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, d, e) (x, y, z, w) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e) (x, y, c, z, w)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, e) (x, y, z, w) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e) (x, y, z, d, w)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d) (x, y, z, w) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e) (x, y, z, w, e)
instance Haskus.Utils.Tuple.ReorderTuple (b, c, d, e, f) (x, y, z, w, v) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f) (a, x, y, z, w, v)
instance Haskus.Utils.Tuple.ReorderTuple (a, c, d, e, f) (x, y, z, w, v) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f) (x, b, y, z, w, v)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, d, e, f) (x, y, z, w, v) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f) (x, y, c, z, w, v)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, e, f) (x, y, z, w, v) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f) (x, y, z, d, w, v)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, f) (x, y, z, w, v) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f) (x, y, z, w, e, v)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e) (x, y, z, w, v) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f) (x, y, z, w, v, f)
instance Haskus.Utils.Tuple.ReorderTuple (b, c, d, e, f, g) (x, y, z, w, v, u) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g) (a, x, y, z, w, v, u)
instance Haskus.Utils.Tuple.ReorderTuple (a, c, d, e, f, g) (x, y, z, w, v, u) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g) (x, b, y, z, w, v, u)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, d, e, f, g) (x, y, z, w, v, u) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g) (x, y, c, z, w, v, u)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, e, f, g) (x, y, z, w, v, u) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g) (x, y, z, d, w, v, u)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, f, g) (x, y, z, w, v, u) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g) (x, y, z, w, e, v, u)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, g) (x, y, z, w, v, u) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g) (x, y, z, w, v, f, u)
instance Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f) (x, y, z, w, v, u) => Haskus.Utils.Tuple.ReorderTuple (a, b, c, d, e, f, g) (x, y, z, w, v, u, g)
instance Haskus.Utils.Tuple.TupleCons a (GHC.Tuple.Unit b) (a, b)
instance Haskus.Utils.Tuple.TupleCons a (b, c) (a, b, c)
instance Haskus.Utils.Tuple.TupleCons a (b, c, d) (a, b, c, d)
instance Haskus.Utils.Tuple.TupleCons a (b, c, d, e) (a, b, c, d, e)
instance Haskus.Utils.Tuple.TupleCons a (b, c, d, e, f) (a, b, c, d, e, f)
instance Haskus.Utils.Tuple.TupleTail (a, b) (GHC.Tuple.Unit b)
instance Haskus.Utils.Tuple.TupleTail (a, b, c) (b, c)
instance Haskus.Utils.Tuple.TupleTail (a, b, c, d) (b, c, d)
instance Haskus.Utils.Tuple.TupleTail (a, b, c, d, e) (b, c, d, e)
instance Haskus.Utils.Tuple.TupleTail (a, b, c, d, e, f) (b, c, d, e, f)


-- | Heterogeneous list
module Haskus.Utils.HList

-- | Heterogeneous list
data family HList (l :: [*])
infixr 2 `HCons`

-- | Head
hHead :: HList (e : l) -> e

-- | Tail
hTail :: HList (e : l) -> HList l

-- | Length
hLength :: forall xs. KnownNat (Length xs) => HList xs -> Word
hAppend :: HAppendList l1 l2 => HList l1 -> HList l2 -> HList (Concat l1 l2)

-- | Like HFoldr but only use types, not values!
--   
--   It allows us to foldr over a list of types, without any associated
--   hlist of values.
class HFoldr' f v (l :: [*]) r
hFoldr' :: HFoldr' f v l r => f -> v -> HList l -> r

-- | Like HFoldl but only use types, not values!
--   
--   It allows us to foldl over a list of types, without any associated
--   hlist of values.
class HFoldl' f (z :: *) xs (r :: *)
hFoldl' :: HFoldl' f z xs r => f -> z -> HList xs -> r

-- | Convert between hlists and tuples
class HTuple v

-- | Convert an heterogeneous list into a tuple
hToTuple :: HTuple v => HList v -> Tuple v

-- | Convert a tuple into an heterogeneous list
hFromTuple :: HTuple v => Tuple v -> HList v

-- | Apply the function identified by the data type f from type a to type
--   b.
class Apply f a b
apply :: Apply f a b => f -> a -> b
class HZipList x y l | x y -> l, l -> x y
hZipList :: HZipList x y l => HList x -> HList y -> HList l
class HFoldr f v (l :: [*]) r
hFoldr :: HFoldr f v l r => f -> v -> HList l -> r
class HFoldl f (z :: *) xs (r :: *)
hFoldl :: HFoldl f z xs r => f -> z -> HList xs -> r
class HReverse xs sx | xs -> sx, sx -> xs
hReverse :: HReverse xs sx => HList xs -> HList sx
instance GHC.Classes.Eq (Haskus.Utils.HList.HList '[])
instance (GHC.Classes.Eq x, GHC.Classes.Eq (Haskus.Utils.HList.HList xs)) => GHC.Classes.Eq (Haskus.Utils.HList.HList (x : xs))
instance GHC.Classes.Ord (Haskus.Utils.HList.HList '[])
instance (GHC.Classes.Ord x, GHC.Classes.Ord (Haskus.Utils.HList.HList xs)) => GHC.Classes.Ord (Haskus.Utils.HList.HList (x : xs))
instance Haskus.Utils.HList.HTuple '[]
instance Haskus.Utils.HList.HTuple '[a]
instance Haskus.Utils.HList.HTuple '[a, b]
instance Haskus.Utils.HList.HTuple '[a, b, c]
instance Haskus.Utils.HList.HTuple '[a, b, c, d]
instance Haskus.Utils.HList.HTuple '[a, b, c, d, e]
instance Haskus.Utils.HList.HTuple '[a, b, c, d, e, f]
instance Haskus.Utils.HList.HTuple '[a, b, c, d, e, f, g]
instance Haskus.Utils.HList.HTuple '[a, b, c, d, e, f, g, h]
instance Haskus.Utils.HList.HTuple '[a, b, c, d, e, f, g, h, i]
instance Haskus.Utils.HList.HTuple '[a, b, c, d, e, f, g, h, i, j]
instance Haskus.Utils.HList.HTuple '[a, b, c, d, e, f, g, h, i, j, k]
instance Haskus.Utils.HList.HTuple '[a, b, c, d, e, f, g, h, i, j, k, l]
instance (Haskus.Utils.HList.HRevApp xs '[] sx, Haskus.Utils.HList.HRevApp sx '[] xs) => Haskus.Utils.HList.HReverse xs sx
instance Haskus.Utils.HList.HRevApp '[] l2 l2
instance Haskus.Utils.HList.HRevApp l (x : l') z => Haskus.Utils.HList.HRevApp (x : l) l' z
instance Haskus.Utils.HList.HZipList '[] '[] '[]
instance ((x, y) Data.Type.Equality.~ z, Haskus.Utils.HList.HZipList xs ys zs) => Haskus.Utils.HList.HZipList (x : xs) (y : ys) (z : zs)
instance (zx Data.Type.Equality.~ (z, x), Haskus.Utils.HList.Apply f zx z', Haskus.Utils.HList.HFoldl' f z' xs r) => Haskus.Utils.HList.HFoldl' f z (x : xs) r
instance (z Data.Type.Equality.~ z') => Haskus.Utils.HList.HFoldl' f z '[] z'
instance (zx Data.Type.Equality.~ (z, x), Haskus.Utils.HList.Apply f zx z', Haskus.Utils.HList.HFoldl f z' xs r) => Haskus.Utils.HList.HFoldl f z (x : xs) r
instance (z Data.Type.Equality.~ z') => Haskus.Utils.HList.HFoldl f z '[] z'
instance (v Data.Type.Equality.~ v') => Haskus.Utils.HList.HFoldr' f v '[] v'
instance (Haskus.Utils.HList.Apply f (e, r) r', Haskus.Utils.HList.HFoldr' f v l r) => Haskus.Utils.HList.HFoldr' f v (e : l) r'
instance (v Data.Type.Equality.~ v') => Haskus.Utils.HList.HFoldr f v '[] v'
instance (Haskus.Utils.HList.Apply f (e, r) r', Haskus.Utils.HList.HFoldr f v l r) => Haskus.Utils.HList.HFoldr f v (e : l) r'
instance Haskus.Utils.HList.HAppendList '[] l2
instance Haskus.Utils.HList.HAppendList l l' => Haskus.Utils.HList.HAppendList (x : l) l'
instance GHC.Show.Show (Haskus.Utils.HList.HList '[])
instance (GHC.Show.Show e, GHC.Show.Show (Haskus.Utils.HList.HList l)) => GHC.Show.Show (Haskus.Utils.HList.HList (e : l))