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


-- | List-like structures with static checks on the number of elements
--   
--   We provide a data type that allows to store a list-like structure with
--   at least or exactly <tt>n</tt> elements, where <tt>n</tt> is fixed in
--   the type in a kind of Peano encoding and is usually small. The
--   datatype is intended to increase safety by making functions total that
--   are partial on plain lists. E.g. on a non-empty list, <a>head</a> and
--   <a>tail</a> are always defined.
--   
--   The package uses Haskell 98.
--   
--   Similar packages:
--   
--   <ul>
--   <li><tt>NonEmptyList</tt>: restricted to lists, minimum number of
--   elements: 1</li>
--   <li><tt>NonEmpty</tt>: restricted to lists, minimum number of
--   elements: 1, designed for unqualified use of identifiers</li>
--   <li><tt>Cardinality</tt>:<tt>NeverEmptyList</tt></li>
--   <li><a>http://www.haskell.org/haskellwiki/Non-empty_list</a></li>
--   </ul>
--   
--   Related packages:
--   
--   <ul>
--   <li><tt>Stream</tt>: Lists that contain always infinitely many
--   elements.</li>
--   <li><tt>fixed-list</tt>: Uses the same data structure as this package
--   but is intended for fixing the number of elements in a list. Requires
--   multi-parameter type classes with functional dependencies.</li>
--   </ul>
@package non-empty
@version 0.0

module Data.NonEmpty.Class
class Empty f
empty :: Empty f => f a
class Cons f
cons :: Cons f => a -> f a -> f a
class View f
viewL :: View f => f a -> Maybe (a, f a)
class Singleton f
singleton :: Singleton f => a -> f a
class Append f
append :: Append f => f a -> f a -> f a
class Zip f
zipWith :: Zip f => (a -> b -> c) -> f a -> f b -> f c
zip :: Zip f => f a -> f b -> f (a, b)
class Sort f
sortBy :: Sort f => (a -> a -> Ordering) -> f a -> f a
insertBy :: Sort f => (a -> a -> Ordering) -> a -> f a -> (a, f a)
sort :: (Ord a, Sort f) => f a -> f a

-- | Insert an element into an ordered list while preserving the order. The
--   first element of the resulting list is returned individually. We need
--   this for construction of a non-empty list.
insert :: (Ord a, Sort f) => a -> f a -> (a, f a)
class Arbitrary f
arbitrary :: (Arbitrary f, Arbitrary a) => Gen (f a)
shrink :: (Arbitrary f, Arbitrary a) => f a -> [f a]
instance Arbitrary []
instance Sort Maybe
instance Sort []
instance Zip Maybe
instance Zip []
instance Append []
instance Singleton Maybe
instance Singleton []
instance View Maybe
instance View []
instance Cons []
instance Empty Maybe
instance Empty []

module Data.NonEmpty

-- | The type <a>T</a> can be used for many kinds of list-like structures
--   with restrictions on the size.
--   
--   <ul>
--   <li><tt>T [] a</tt> is a lazy list containing at least one
--   element.</li>
--   <li><tt>T (T []) a</tt> is a lazy list containing at least two
--   elements.</li>
--   <li><tt>T Vector a</tt> is a vector with at least one element. You may
--   also use unboxed vectors but the first element will be stored in a box
--   and you will not be able to use many functions from this module.</li>
--   <li><tt>T Maybe a</tt> is a list that contains one or two
--   elements.</li>
--   <li><tt>T Empty a</tt> is a list that contains exactly one
--   element.</li>
--   <li><tt>T (T Empty) a</tt> is a list that contains exactly two
--   elements.</li>
--   </ul>
data T f a
Cons :: a -> f a -> T f a
head :: T f a -> a
tail :: T f a -> f a
(!:) :: a -> f a -> T f a

-- | Force immediate generation of Cons.
force :: T f a -> T f a

-- | Implementation of <a>&lt;*&gt;</a> without the <a>Empty</a> constraint
--   that is needed for <a>pure</a>.
apply :: (Applicative f, Cons f, Append f) => T f (a -> b) -> T f a -> T f b

-- | Implementation of <a>&gt;&gt;=</a> without the <a>Empty</a> constraint
--   that is needed for <a>return</a>.
bind :: (Monad f, Cons f, Append f) => T f a -> (a -> T f b) -> T f b
data Empty a
Empty :: Empty a
toList :: Foldable f => T f a -> [a]
flatten :: Cons f => T f a -> f a
fetch :: View f => f a -> Maybe (T f a)
cons :: Cons f => a -> T f a -> T f a
singleton :: Empty f => a -> T f a
reverse :: (Foldable f, Cons f, Empty f) => T f a -> T f a
mapHead :: (a -> a) -> T f a -> T f a
mapTail :: (f a -> g a) -> T f a -> T g a
init :: (Zip f, Cons f) => T f a -> f a
last :: Foldable f => T f a -> a
foldl1 :: Foldable f => (a -> a -> a) -> T f a -> a

-- | maximum is a total function
maximum :: (Ord a, Foldable f) => T f a -> a

-- | minimum is a total function
minimum :: (Ord a, Foldable f) => T f a -> a

-- | sum does not need a zero for initialization
sum :: (Num a, Foldable f) => T f a -> a

-- | product does not need a one for initialization
product :: (Num a, Foldable f) => T f a -> a
append :: (Cons f, Append f) => T f a -> T f a -> T f a
cycle :: (Cons f, Append f) => T f a -> T f a
zipWith :: Zip f => (a -> b -> c) -> T f a -> T f b -> T f c

-- | If you nest too many non-empty lists then the efficient merge-sort
--   (linear-logarithmic runtime) will degenerate to an inefficient
--   insert-sort (quadratic runtime).
sortBy :: Sort f => (a -> a -> Ordering) -> T f a -> T f a
sort :: (Ord a, Sort f) => T f a -> T f a
insertBy :: (Sort f, Cons f) => (a -> a -> Ordering) -> a -> T f a -> T f a
insert :: (Ord a, Sort f, Cons f) => a -> T f a -> T f a


-- | Functions that cope both with plain and non-empty structures.
module Data.NonEmpty.Mixed
groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [T [] a]
segmentBefore :: Foldable f => (a -> Bool) -> f a -> ([a], [T [] a])
scanl :: (a -> b -> a) -> a -> [b] -> T [] a
genericScanl :: Foldable f => (a -> b -> a) -> a -> f b -> T [] a
insertBy :: Sort f => (a -> a -> Ordering) -> a -> f a -> T f a
insert :: (Ord a, Sort f) => a -> f a -> T f a
appendLeft :: (Append f, View f, Cons f) => f a -> T f a -> T f a
tails :: (View f, Empty f) => f a -> T [] (f a)
inits :: (View f, Cons f, Empty f) => f a -> T [] (f a)
appendRight :: Append f => T f a -> f a -> T f a