-- 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. Also contains some functions to find
--   out both minimum and maximum elements of the finite Foldable
--   structures.
@package subG
@version 0.2.1.0


-- | 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.
module Data.SubG

-- | Some extension to the <a>Foldable</a> and <a>Monoid</a> classes.
class (Foldable t, Eq a, Eq (t a)) => InsertLeft t 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>. Uses strict variant
--   of the foldl, so is strict and the data must be finite.
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>. 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>. 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.
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>. 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>. Uses strict variant
--   of the foldl, so is strict and the data must be finite.
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>. 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>. 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.
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>. 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>. Uses strict variant
--   of the foldl, so is strict and the data must be finite.
splitAtG :: (Integral b, InsertLeft t a, Monoid (t a)) => b -> 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. Uses strict variant of
--   the foldl, so is strict and the data must be finite.
safeTailG :: (InsertLeft t a, Monoid (t a)) => t a -> t 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
instance GHC.Classes.Eq a => Data.SubG.InsertLeft [] a


-- | Functions to find both minimum and maximum elements of the
--   <a>Foldable</a> structure of the <a>Ord</a>ered elements.
module Data.MinMax

-- | Returns a pair where the first element is the minimum element from the
--   two given ones and the second one is the maximum. If the arguments are
--   equal then the tuple contains equal elements.
minmaxP :: Ord a => a -> a -> (a, a)

-- | A ternary predicate to check whether the third argument lies between
--   the first two unequal ones or whether they are all equal.
betweenNX :: Ord a => a -> a -> a -> Bool

-- | Finds out the minimum and maximum values of the finite structure. If
--   the latter one is empty returns <a>Nothing</a>, if all the elements
--   are equal (or it has just one) then it returns <a>Just</a> tuple of
--   equal elements.
minMax :: (Ord a, Foldable t) => t a -> Maybe (a, a)

-- | A generalized variant of the <a>minMax</a> where you can specify your
--   own comparison function.
minMaxBy :: (Ord a, Foldable t) => (a -> a -> Ordering) -> t a -> Maybe (a, a)

-- | Given a finite structure with at least 3 elements returns a tuple with
--   the two most minimum elements (the first one is less than the second
--   one) and the maximum element. If the structure has less elements,
--   returns <a>Nothing</a>. Uses just three passes through the structure,
--   so may be more efficient than some other approaches.
minMax21 :: (Ord a, InsertLeft t a, Monoid (t a)) => t a -> Maybe ((a, a), a)

-- | Given a finite structure with at least 3 elements returns a tuple with
--   the minimum element and two maximum elements (the first one is less
--   than the second one). If the structure has less elements, returns
--   <a>Nothing</a>. Uses just three passes through the structure, so may
--   be more efficient than some other approaches.
minMax12 :: (Ord a, InsertLeft t a, Monoid (t a)) => t a -> Maybe (a, (a, a))

-- | Given a finite structure with at least 4 elements returns a tuple with
--   two minimum elements and two maximum elements. If the structure has
--   less elements, returns <a>Nothing</a>. Uses just three passes through
--   the structure, so may be more efficient than some other approaches.
minMax22 :: (Ord a, InsertLeft t a, Monoid (t a)) => t a -> Maybe ((a, a), (a, a))