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


-- | Some extension to the Foldable and Monoid classes.
--   
--   Introduces a new class InsertLeft — the class of types of values that
--   can be inserted from the left to the Foldable structure that is a data
--   that is also the Monoid instance. Is a fork of the
--   <a>https://hackage.haskell.org/package/subG</a>.
@package monoid-insertleft
@version 0.1.0.1


-- | Some extension to the <a>Foldable</a> and <a>Monoid</a> classes.
--   Introduces a new class <a>InsertLeft</a> -- the class of types of
--   values that can be inserted from the left to the <a>Foldable</a>
--   structure that is simultaneously the data that is also the
--   <a>Monoid</a> instance. For lists as instances of <a>InsertLeft</a>
--   and <a>Monoid</a> just use the basic library functions from GHC.List
--   or Data.List modules where possible. Is a fork of
--   <a>https://hackage.haskell.org/package/subG-0.6.1.0</a>.
module Data.InsertLeft

-- | Some extension to the <a>Foldable</a> and <a>Monoid</a> classes.
class (Foldable t, Eq a, Eq t a) => InsertLeft (t :: Type -> Type) a
(%@) :: InsertLeft t a => a -> t a -> t a
(%^) :: InsertLeft t a => t a -> t (t a) -> t (t a)
infixr 1 %@
infixr 1 %^

-- | Inspired by:
--   <a>https://hackage.haskell.org/package/base-4.14.0.0/docs/src/Data.OldList.html#words</a>
--   and: Graham Hutton. A tutorial on the universality and expressiveness
--   of fold. <i>J. Functional Programming</i> 9 (4): 355–372, July 1999.
--   that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Is similar to the
--   <a>words</a> but operates on more general structures an allows more
--   control.
subG :: (InsertLeft t a, Monoid (t a), Monoid (t (t a))) => t a -> t a -> t (t a)

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Takes the first
--   argument quantity from the right end of the structure preserving the
--   order.
takeFromEndG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Takes the specified
--   quantity from the right end of the structure and then reverses the
--   result.
reverseTakeFromEndG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Drops the first
--   argument quantity from the right end of the structure and returns the
--   result preserving the order.
dropFromEndG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Drops the specified
--   quantity from the right end of the structure and then reverses the
--   result.
reverseDropFromEndG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>.
takeWhile :: (InsertLeft t a, Monoid (t a)) => (a -> Bool) -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>.
dropWhile :: (InsertLeft t a, Monoid (t a)) => (a -> Bool) -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>.
span :: (InsertLeft t a, Monoid (t a)) => (a -> Bool) -> t a -> (t a, t a)

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Splits the
--   structure starting from the end and preserves the order.
splitAtEndG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> (t a, t a)

-- | Prepends and appends the given two first arguments to the third one.
preAppend :: (InsertLeft t a, Monoid (t (t a))) => t a -> t (t a) -> t (t a) -> t (t a)

-- | If a structure is empty, just returns <a>Nothing</a>.
safeHeadG :: Foldable t => t a -> Maybe a

-- | If the structure is empty, just returns itself.
safeInitG :: (InsertLeft t a, Monoid (t a)) => t a -> t a

-- | If the structure is empty, just returns <a>Nothing</a>.
safeLastG :: (InsertLeft t a, Monoid (t a)) => t a -> Maybe a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Acts similarly to
--   the <a>map</a> function from Prelude.
mapG :: (InsertLeft t b, Monoid (t b)) => (a -> b) -> t a -> t b

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Acts similarly to
--   <tt>filter</tt> function from Prelude.
filterG :: (InsertLeft t a, Monoid (t a)) => (a -> Bool) -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Acts similarly to
--   <tt>partition</tt> function from Data.List. Practically is a rewritten
--   for more general variants function partition from
--   <a>https://hackage.haskell.org/package/base-4.14.0.0/docs/src/Data.OldList.html#partition</a>
partitionG :: (InsertLeft t a, Monoid (t a)) => (a -> Bool) -> t a -> (t a, t a)

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Is analogous to the
--   taking the specified quantity from the structure and then reversing
--   the result. Uses strict variant of the foldl, so is not suitable for
--   large amounts of data. Not recommended for performance reasons. For
--   lists just use the combination <tt>(reverse . take n)</tt>.
reverseTakeG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Uses strict variant
--   of the foldl, so is strict and the data must be finite. Not
--   recommended for performance reasons. For lists just use GHC.List.take
--   n.
takeG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Is analogous to the
--   dropping the specified quantity from the structure and then reversing
--   the result. Uses strict variant of the foldl, so is strict and the
--   data must be finite. Not recommended for performance reasons. For
--   lists just use @ (reverse . drop n) combination.
reverseDropG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Uses strict variant
--   of the foldl, so is strict and the data must be finite. Not
--   recommended for performance reasons. For lists just use the
--   GHC.List.drop.
dropG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> t a

-- | Inspired by: Graham Hutton. A tutorial on the universality and
--   expressiveness of fold. <i>J. Functional Programming</i> 9 (4):
--   355–372, July 1999. that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Uses strict variant
--   of the foldl, so is strict and the data must be finite. Not
--   recommended for performance reasons. For lists just use the
--   GHC.List.splitAt.
splitAtG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> t a -> (t a, t a)

-- | If the structure is empty, just returns itself. Uses strict variant of
--   the foldl, so is strict and the data must be finite. Not recommended
--   for performance reasons. For lists just use Data.List.tail or
--   something equivalent.
safeTailG :: (InsertLeft t a, Monoid (t a)) => t a -> t a
instance GHC.Classes.Eq a => Data.InsertLeft.InsertLeft [] a


-- | Generalization of the <a>unfoldr</a> for the data type that has
--   <a>InsertLeft</a> and <a>Monoid</a> instances. Inspired by:
--   <a>https://www.works-hub.com/learn/number-anamorphisms-aka-unfolds-explained-50e1a</a>
--   by Marty Stumpf. Is a fork of
--   <a>https://hackage.haskell.org/package/subG-0.6.1.0</a>
module Data.InsertLeft.Unfold

-- | Inspired by:
--   <a>https://hackage.haskell.org/package/base-4.14.0.0/docs/src/Data.OldList.html#words</a>
--   and: Graham Hutton. A tutorial on the universality and expressiveness
--   of fold. <i>J. Functional Programming</i> 9 (4): 355–372, July 1999.
--   that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Also inspired by:
--   <a>https://www.works-hub.com/learn/number-anamorphisms-aka-unfolds-explained-50e1a</a>
--   by Marty Stumpf. Generalizes the <a>unfoldr</a> function not only for
--   lists, but for the data type that has <a>InsertLeft</a> and
--   <a>Monoid</a> instances.
unfoldG :: (InsertLeft t a, Monoid (t a)) => (b -> Maybe (a, b)) -> b -> t a

-- | Inspired by:
--   <a>https://hackage.haskell.org/package/base-4.14.0.0/docs/src/Data.OldList.html#words</a>
--   and: Graham Hutton. A tutorial on the universality and expressiveness
--   of fold. <i>J. Functional Programming</i> 9 (4): 355–372, July 1999.
--   that is available at the URL:
--   <a>https://www.cs.nott.ac.uk/~pszgmh/fold.pdf</a>. Also inspired by:
--   <a>https://www.works-hub.com/learn/number-anamorphisms-aka-unfolds-explained-50e1a</a>
--   by Marty Stumpf. Generalizes the <a>iterate</a> function not only for
--   lists, but for the data type that has <a>InsertLeft</a> and
--   <a>Monoid</a> instances.
iterateG :: (InsertLeft t a, Monoid (t a)) => (a -> a) -> a -> t a