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


-- | List-like structures with static restrictions on the number of elements
--   
--   We provide the data type <tt>NonEmpty</tt> 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.
--   
--   There are more such data types like <tt>Optional</tt> and
--   <tt>Empty</tt>. Together with <tt>NonEmpty</tt> you can define a list
--   type for every finite set of admissible list lengths.
--   
--   The datatype can be combined with Lists, Sequences and Sets (from the
--   <tt>containers</tt> package).
--   
--   The package needs only Haskell 98.
--   
--   Similar packages:
--   
--   <ul>
--   <li><tt>semigroups</tt>, <tt>semigroupoids</tt>: restricted to lists,
--   minimum number of elements: 1, provides more type classes tailored to
--   the use of non-empty lists.</li>
--   <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><tt>mono-traversable</tt>:<tt>Data.MinLen</tt>: allows to specify
--   a minimum number of elements using type families and works also for
--   monomorphic data structures like <a>ByteString</a></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-length</tt>: Uses the data structure of this package and
--   defines a closed-world class for fixed-length lists and an according
--   index type.</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.3.4

module Data.NonEmpty.Class
class Empty f
empty :: Empty f => f a
class Cons f
cons :: Cons f => a -> f a -> f a
infixr 5 `cons`
class Snoc f
snoc :: Snoc f => f a -> a -> f a
snocDefault :: (Cons f, Traversable f) => f a -> a -> f a
class ViewL f
viewL :: ViewL f => f a -> Maybe (a, f a)
class ViewR f
viewR :: ViewR f => f a -> Maybe (f a, a)
class (ViewL f, ViewR f) => View f
viewRDefault :: (ViewL f, Traversable f) => f a -> Maybe (f a, a)
class Singleton f
singleton :: Singleton f => a -> f a
class Append f
append :: Append f => f a -> f a -> f a
infixr 5 `append`

-- | It must hold:
--   
--   <pre>
--   fmap f xs
--      = zipWith (\x _ -&gt; f x) xs xs
--      = zipWith (\_ x -&gt; f x) xs xs
--   </pre>
class Functor f => Zip f
zipWith :: Zip f => (a -> b -> c) -> f a -> f b -> f c
zipWith3 :: Zip f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
zipWith4 :: Zip f => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
zip :: Zip f => f a -> f b -> f (a, b)
zip3 :: Zip f => f a -> f b -> f c -> f (a, b, c)
zip4 :: Zip f => f a -> f b -> f c -> f d -> f (a, b, c, d)
class Repeat f

-- | Create a container with as many copies as possible of a given value.
--   That is, for a container with fixed size <tt>n</tt>, the call
--   <tt>repeat x</tt> will generate a container with <tt>n</tt> copies of
--   <tt>x</tt>.
repeat :: Repeat f => a -> f a
class Repeat f => Iterate f
iterate :: Iterate f => (a -> a) -> a -> f a

-- | We need to distinguish between <a>Sort</a> and <a>SortBy</a>, since
--   there is an <tt>instance Sort Set</tt> but there cannot be an
--   <tt>instance SortBy Set</tt>.
class Sort f
sort :: (Sort f, Ord a) => f a -> f a

-- | Default implementation for <a>sort</a> based on <a>sortBy</a>.
sortDefault :: (Ord a, SortBy f) => f a -> f a
class Sort f => SortBy f
sortBy :: SortBy f => (a -> a -> Ordering) -> f a -> f a
class Sort f => SortKey f
sortKey :: (SortKey f, Ord b) => (a -> b) -> f a -> f a
sortKeyGen :: (SortBy f, Functor f, Ord b) => (a -> b) -> f a -> f a
class Reverse f
reverse :: Reverse f => f a -> f a
class Show f
showsPrec :: (Show f, Show a) => Int -> f a -> ShowS
class Arbitrary f
arbitrary :: (Arbitrary f, Arbitrary a) => Gen (f a)
shrink :: (Arbitrary f, Arbitrary a) => f a -> [f a]
class (Arbitrary f) => Gen f
genOf :: Gen f => Gen a -> Gen (f a)
class NFData f
rnf :: (NFData f, NFData a) => f a -> ()
class Ix f
range :: (Ix f, Ix i) => (f i, f i) -> [f i]
index :: (Ix f, Ix i) => (f i, f i) -> f i -> Int
inRange :: (Ix f, Ix i) => (f i, f i) -> f i -> Bool
rangeSize :: (Ix f, Ix i) => (f i, f i) -> Int

-- | The default implementation causes quadratic runtime on nested index
--   tuple types. This affects the <a>index</a> function, too.
rangeSizeIndex :: (Ix f, Ix i) => (f i, f i) -> (Int, f i -> Int)

-- | A custom implementation of this function allows for an even more
--   efficient implementation of <a>index</a> on nested NonEmpty
--   constructors.
indexHorner :: (Ix f, Ix i) => (f i, f i) -> Int -> f i -> Int
instance Data.NonEmpty.Class.NFData GHC.Maybe.Maybe
instance Data.NonEmpty.Class.NFData []
instance Data.NonEmpty.Class.NFData Data.Set.Internal.Set
instance Control.DeepSeq.NFData k => Data.NonEmpty.Class.NFData (Data.Map.Internal.Map k)
instance Data.NonEmpty.Class.Gen []
instance Data.NonEmpty.Class.Gen Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Gen GHC.Maybe.Maybe
instance (Test.QuickCheck.Arbitrary.Arbitrary k, GHC.Classes.Ord k) => Data.NonEmpty.Class.Gen (Data.Map.Internal.Map k)
instance Data.NonEmpty.Class.Arbitrary []
instance Data.NonEmpty.Class.Arbitrary Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Arbitrary GHC.Maybe.Maybe
instance (Test.QuickCheck.Arbitrary.Arbitrary k, GHC.Classes.Ord k) => Data.NonEmpty.Class.Arbitrary (Data.Map.Internal.Map k)
instance Data.NonEmpty.Class.Show []
instance Data.NonEmpty.Class.Show GHC.Maybe.Maybe
instance Data.NonEmpty.Class.Show Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Show Data.Set.Internal.Set
instance Data.NonEmpty.Class.Reverse []
instance Data.NonEmpty.Class.Reverse GHC.Maybe.Maybe
instance Data.NonEmpty.Class.Reverse Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.SortKey []
instance Data.NonEmpty.Class.SortKey GHC.Maybe.Maybe
instance Data.NonEmpty.Class.SortKey Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.SortBy []
instance Data.NonEmpty.Class.SortBy GHC.Maybe.Maybe
instance Data.NonEmpty.Class.SortBy Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Sort []
instance Data.NonEmpty.Class.Sort GHC.Maybe.Maybe
instance Data.NonEmpty.Class.Sort Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Sort Data.Set.Internal.Set
instance Data.NonEmpty.Class.Iterate []
instance Data.NonEmpty.Class.Iterate GHC.Maybe.Maybe
instance Data.NonEmpty.Class.Repeat []
instance Data.NonEmpty.Class.Repeat GHC.Maybe.Maybe
instance Data.NonEmpty.Class.Zip []
instance Data.NonEmpty.Class.Zip GHC.Maybe.Maybe
instance Data.NonEmpty.Class.Zip Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Append []
instance Data.NonEmpty.Class.Append Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Singleton []
instance Data.NonEmpty.Class.Singleton GHC.Maybe.Maybe
instance Data.NonEmpty.Class.Singleton Data.Set.Internal.Set
instance Data.NonEmpty.Class.Singleton Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.View []
instance Data.NonEmpty.Class.View GHC.Maybe.Maybe
instance Data.NonEmpty.Class.View Data.Set.Internal.Set
instance Data.NonEmpty.Class.View Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.ViewR []
instance Data.NonEmpty.Class.ViewR GHC.Maybe.Maybe
instance Data.NonEmpty.Class.ViewR Data.Set.Internal.Set
instance Data.NonEmpty.Class.ViewR Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.ViewL []
instance Data.NonEmpty.Class.ViewL GHC.Maybe.Maybe
instance Data.NonEmpty.Class.ViewL Data.Set.Internal.Set
instance Data.NonEmpty.Class.ViewL Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Snoc []
instance Data.NonEmpty.Class.Snoc Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Cons []
instance Data.NonEmpty.Class.Cons Data.Sequence.Internal.Seq
instance Data.NonEmpty.Class.Empty []
instance Data.NonEmpty.Class.Empty GHC.Maybe.Maybe
instance Data.NonEmpty.Class.Empty Data.Set.Internal.Set
instance Data.NonEmpty.Class.Empty (Data.Map.Internal.Map k)
instance Data.NonEmpty.Class.Empty Data.Sequence.Internal.Seq

module Data.Empty
data T a
Cons :: T a
switch :: b -> T a -> b
instance GHC.Classes.Ord (Data.Empty.T a)
instance GHC.Classes.Eq (Data.Empty.T a)
instance GHC.Show.Show (Data.Empty.T a)
instance Data.NonEmpty.Class.Show Data.Empty.T
instance GHC.Base.Functor Data.Empty.T
instance Data.Foldable.Foldable Data.Empty.T
instance Data.Traversable.Traversable Data.Empty.T
instance Data.NonEmpty.Class.ViewL Data.Empty.T
instance Data.NonEmpty.Class.ViewR Data.Empty.T
instance Data.NonEmpty.Class.View Data.Empty.T
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.Empty.T a)
instance Data.NonEmpty.Class.Arbitrary Data.Empty.T
instance Data.NonEmpty.Class.Gen Data.Empty.T
instance Data.NonEmpty.Class.Empty Data.Empty.T
instance Data.NonEmpty.Class.Zip Data.Empty.T
instance Data.NonEmpty.Class.Reverse Data.Empty.T
instance Data.NonEmpty.Class.Sort Data.Empty.T
instance Data.NonEmpty.Class.SortBy Data.Empty.T
instance Data.NonEmpty.Class.Repeat Data.Empty.T
instance Data.NonEmpty.Class.Iterate Data.Empty.T
instance Data.NonEmpty.Class.NFData Data.Empty.T
instance Control.DeepSeq.NFData (Data.Empty.T a)
instance Data.NonEmpty.Class.Ix Data.Empty.T
instance GHC.Ix.Ix i => GHC.Ix.Ix (Data.Empty.T i)

module Data.Append
data T f g a
Cons :: f a -> g a -> T f g a
[fst] :: T f g a -> f a
[snd] :: T f g a -> g a
instance (GHC.Base.Functor f, GHC.Base.Functor g) => GHC.Base.Functor (Data.Append.T f g)
instance (Data.Foldable.Foldable f, Data.Foldable.Foldable g) => Data.Foldable.Foldable (Data.Append.T f g)
instance (Data.Traversable.Traversable f, Data.Traversable.Traversable g) => Data.Traversable.Traversable (Data.Append.T f g)
instance (Data.NonEmpty.Class.NFData f, Data.NonEmpty.Class.NFData g) => Data.NonEmpty.Class.NFData (Data.Append.T f g)
instance (Data.NonEmpty.Class.NFData f, Data.NonEmpty.Class.NFData g, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Data.Append.T f g a)


-- | Generalized version of utility-ht:<a>Data.List.Match</a>.
module Data.NonEmpty.Match

-- | Make a list as long as another one
take :: Zip f => f b -> f a -> f a

-- | the same as <tt>($&gt;)</tt>
replicate :: Functor f => f a -> b -> f b

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>Maybe</tt> is isomorphic to <tt>Optional Empty</tt>.</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>
--   <li><tt>Optional (T Empty) a</tt> is a list that contains zero or two
--   elements.</li>
--   <li>You can create a list type for every finite set of allowed list
--   length by nesting Optional and NonEmpty constructors. If list length
--   <tt>n</tt> is allowed, then place <tt>Optional</tt> at depth
--   <tt>n</tt>, if it is disallowed then place <tt>NonEmpty</tt>. The
--   maximum length is marked by <tt>Empty</tt>.</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
infixr 5 !:

-- | 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
toList :: Foldable f => T f a -> [a]
flatten :: Cons f => T f a -> f a
fetch :: ViewL f => f a -> Maybe (T f a)

-- | Synonym for <a>Cons</a>. For symmetry to <a>snoc</a>.
cons :: a -> f a -> T f a
snoc :: Traversable f => f a -> a -> T f a
singleton :: Empty f => a -> T f a
reverse :: (Traversable f, Reverse 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
viewL :: T f a -> (a, f a)
viewR :: Traversable f => T f a -> (f a, a)
init :: Traversable f => T f a -> f a
last :: Foldable f => T f a -> a
foldl1 :: Foldable f => (a -> a -> a) -> T f a -> a

-- | It holds:
--   
--   <pre>
--   foldl1Map f g = foldl1 f . fmap g
--   </pre>
--   
--   but <a>foldl1Map</a> does not need a <a>Functor</a> instance.
foldl1Map :: Foldable f => (b -> b -> b) -> (a -> b) -> T f a -> b

-- | Fold a non-empty list in a balanced way. <i>Balanced</i> means that
--   each element has approximately the same depth in the operator tree.
--   <i>Approximately the same depth</i> means that the difference between
--   maximum and minimum depth is at most 1. The accumulation operation
--   must be associative and commutative in order to get the same result as
--   <a>foldl1</a> or <tt>foldr1</tt>.
foldBalanced :: (a -> a -> a) -> T [] a -> a
foldBalancedStrict :: (a -> a -> a) -> T [] a -> a

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

-- | maximumBy is a total function
maximumBy :: Foldable f => (a -> a -> Ordering) -> T f a -> a

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

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

-- | minimumBy is a total function
minimumBy :: Foldable f => (a -> a -> Ordering) -> T f a -> a

-- | minimumKey is a total function
minimumKey :: (Ord b, Foldable f) => (a -> b) -> 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
chop :: (a -> Bool) -> [a] -> T [] [a]
append :: (Append f, Traversable f) => T f a -> T f a -> T (T f) a
infixr 5 `append`
appendLeft :: (Append f, Traversable f) => f a -> T f a -> T f a
infixr 5 `appendLeft`
appendRight :: Append f => T f a -> f a -> T f a
infixr 5 `appendRight`

-- | generic variants: <a>cycle</a> or better <tt>Semigroup.cycle</tt>
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
mapAdjacent :: Traversable f => (a -> a -> b) -> T f a -> f b
class Insert f

-- | Insert an element into an ordered list while preserving the order.
insert :: (Insert f, Ord a) => a -> f a -> T f a

-- | Default implementation for <a>insert</a> based on <a>insertBy</a>.
insertDefault :: (Ord a, InsertBy f, SortBy f) => a -> f a -> T f a
class Insert f => InsertBy f
insertBy :: InsertBy f => (a -> a -> Ordering) -> a -> f a -> T f a
scanl :: Traversable f => (b -> a -> b) -> b -> f a -> T f b
scanr :: Traversable f => (a -> b -> b) -> b -> f a -> T f b
tails :: (Traversable f, Cons g, Empty g) => f a -> T f (g a)

-- | Only advised for structures with efficient appending of single
--   elements like <tt>Sequence</tt>. Alternatively you may consider
--   <a>initsRev</a>.
inits :: (Traversable f, Snoc g, Empty g) => f a -> T f (g a)
initsRev :: (Traversable f, Cons g, Empty g, Reverse g) => f a -> T f (g a)
removeEach :: Traversable f => T f a -> T f (a, f a)

-- | <pre>
--   \xs -&gt; mapMaybe EitherHT.maybeLeft (NonEmpty.flatten xs) == either NonEmpty.flatten fst (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int)))
--   </pre>
--   
--   <pre>
--   \xs -&gt; mapMaybe EitherHT.maybeRight (NonEmpty.flatten xs) == either (const []) (NonEmpty.flatten . snd) (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int)))
--   </pre>
--   
--   <pre>
--   \xs -&gt; NonEmpty.partitionEithersRight (fmap EitherHT.swap xs) == EitherHT.mapLeft swap (EitherHT.swap (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int))))
--   </pre>
partitionEithersLeft :: T [] (Either a b) -> Either (T [] a) ([a], T [] b)

-- | <pre>
--   \xs -&gt; NonEmpty.partitionEithersLeft (fmap EitherHT.swap xs) == EitherHT.mapRight swap (EitherHT.swap (NonEmpty.partitionEithersRight (xs::NonEmpty.T[](Either Char Int))))
--   </pre>
partitionEithersRight :: T [] (Either a b) -> Either (T [] a, [b]) (T [] b)

module Data.NonEmpty.Set
data T a

-- | We cannot have a reasonable <tt>instance Insert Set</tt>, since the
--   <tt>instance Insert (NonEmpty Set)</tt> would preserve duplicate
--   leading elements, whereas <a>Set</a> does not.
--   
--   However, the <tt>instance Insert NonEmpty</tt> is not the problem. A
--   general type like
--   
--   <pre>
--   insertSet :: (Insert f, Ord a) =&gt; a -&gt; f a -&gt; NonEmpty f a
--   </pre>
--   
--   cannot work, since it can be instantiated to
--   
--   <pre>
--   insertSet :: (Ord a) =&gt; a -&gt; NonEmpty Set a -&gt; NonEmpty (NonEmpty Set) a
--   </pre>
--   
--   and this is obviously wrong: <tt>insertSet x (singleton x)</tt> has
--   only one element, not two.
insert :: Ord a => a -> Set a -> T a
singleton :: a -> T a
member :: Ord a => a -> T a -> Bool
size :: T a -> Int
fromList :: Ord a => T [] a -> T a
fromAscList :: Ord a => T [] a -> T a
toAscList :: T a -> T [] a
fetch :: Ord a => Set a -> Maybe (T a)
flatten :: Ord a => T a -> Set a
union :: Ord a => T a -> T a -> T a
unionLeft :: Ord a => Set a -> T a -> T a
unionRight :: Ord a => T a -> Set a -> T a
findMin :: T a -> a
findMax :: T a -> a
delete :: Ord k => k -> T k -> Set k
deleteMin :: T a -> Set a
deleteMax :: Ord a => T a -> Set a
deleteFindMin :: T a -> (a, Set a)
deleteFindMax :: Ord a => T a -> (a, Set a)
minView :: T a -> (a, Set a)
maxView :: Ord a => T a -> (a, Set a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.NonEmpty.Set.T a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.NonEmpty.Set.T a)
instance GHC.Show.Show a => GHC.Show.Show (Data.NonEmpty.Set.T a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.NonEmpty.Set.T a)
instance Data.NonEmpty.Class.NFData Data.NonEmpty.Set.T
instance (Test.QuickCheck.Arbitrary.Arbitrary a, GHC.Classes.Ord a) => Test.QuickCheck.Arbitrary.Arbitrary (Data.NonEmpty.Set.T a)


-- | Functions that cope both with plain and non-empty structures.
--   
--   If there are two versions of a function, where one works on
--   fixed-length lists, then place the fixed-length list variant in
--   NonEmpty and the other one here.
module Data.NonEmpty.Mixed
groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [T [] a]
groupPairs :: (Foldable f, Eq a) => f (a, b) -> [(a, T [] b)]
groupKey :: (Foldable f, Eq a) => (b -> a) -> f b -> [(a, T [] b)]
groupEithers :: Foldable f => f (Either a b) -> [Either (T [] a) (T [] b)]
segmentAfter :: Foldable f => (a -> Bool) -> f a -> ([T [] a], [a])
segmentBefore :: Foldable f => (a -> Bool) -> f a -> ([a], [T [] a])
filterToInfixes :: Foldable f => (a -> Bool) -> f a -> [T [] a]
mapAdjacent :: (Cons f, Zip f) => (a -> a -> b) -> T f a -> f b
take :: (View g, Repeat f, Traversable f) => g a -> Maybe (f a)
splitAt :: (View g, Repeat f, Traversable f) => g a -> (Maybe (f a), g a)
sliceVertical :: (View g, Repeat f, Traversable f) => g a -> ([f a], g a)

-- | This implementation is more efficient for Sequence than <a>viewR</a>.
viewR :: (ViewR f, Empty f, Cons f) => T f a -> (f a, a)
init :: (ViewR f, Empty f, Cons f) => T f a -> f a
last :: ViewR f => T f a -> a
tails :: (ViewL f, Empty f) => f a -> T [] (f a)
inits :: (ViewL f, Cons f, Empty f) => f a -> T [] (f a)
appendLeft :: Cons f => [a] -> f a -> f a
iterate :: (Repeat f, Traversable f) => (a -> a) -> a -> f a
class Choose f

-- | Select tuples of list elements: <tt>choose "abc" ==
--   [<tt>a</tt>!:<tt>b</tt>!:empty,<tt>a</tt>!:<tt>c</tt>!:empty,<tt>b</tt>!:<tt>c</tt>!:empty]</tt>
choose :: Choose f => [a] -> [f a]
instance Data.NonEmpty.Mixed.Choose Data.Empty.T
instance Data.NonEmpty.Mixed.Choose f => Data.NonEmpty.Mixed.Choose (Data.NonEmptyPrivate.T f)
instance Data.NonEmpty.Mixed.Choose []

module Data.NonEmpty.Map
data T k a

-- | <pre>
--   \k a -&gt; forAllMap $ \m -&gt; Map.insert k a m == NonEmptyMap.flatten (NonEmptyMap.insert k a m)
--   </pre>
insert :: Ord k => k -> a -> Map k a -> T k a

-- | <pre>
--   \k a -&gt; forAllMap $ \m -&gt; Map.insertWith (++) k a m == NonEmptyMap.flatten (NonEmptyMap.insertWith (++) k a m)
--   </pre>
insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> T k a
singleton :: k -> a -> T k a
member :: Ord k => k -> T k a -> Bool
size :: T k a -> Int
elems :: T k a -> T [] a
keys :: T k a -> T [] k
keysSet :: Ord k => T k a -> T k
lookup :: Ord k => k -> T k a -> Maybe a

-- | <pre>
--   \k -&gt; forAllNonEmptyMap $ \m -&gt; Map.delete k (NonEmptyMap.flatten m) == NonEmptyMap.delete k m
--   </pre>
delete :: Ord k => k -> T k a -> Map k a
minViewWithKey :: T k a -> ((k, a), Map k a)
maxViewWithKey :: Ord k => T k a -> ((k, a), Map k a)

-- | <pre>
--   \xs -&gt; Map.fromList (NonEmpty.flatten xs) == NonEmptyMap.flatten (NonEmptyMap.fromList (xs::NonEmpty.T [] (Int,Char)))
--   </pre>

-- | <i>Warning: Dangerous because it silently drops colliding key/value
--   pairs. Better use fromListWith.</i>
fromList :: Ord k => T [] (k, a) -> T k a

-- | <pre>
--   \xs -&gt; Map.fromListWith (++) (NonEmpty.flatten xs) == NonEmptyMap.flatten (NonEmptyMap.fromListWith (++) (xs::NonEmpty.T [] (Int,String)))
--   </pre>
fromListWith :: Ord k => (a -> a -> a) -> T [] (k, a) -> T k a

-- | <pre>
--   forAllNonEmptyMap $ \m -&gt; NonEmptyMap.fromAscList (NonEmptyMap.toAscList m) == m
--   </pre>
fromAscList :: Ord k => T [] (k, a) -> T k a

-- | <pre>
--   forAllNonEmptyMap $ \m -&gt; NonEmpty.flatten (NonEmptyMap.toAscList m) == Map.toAscList (NonEmptyMap.flatten m)
--   </pre>
toAscList :: T k a -> T [] (k, a)
fetch :: Ord k => Map k a -> Maybe (T k a)
flatten :: Ord k => T k a -> Map k a

-- | <pre>
--   forAllNonEmptyMap $ \xs -&gt; forAllNonEmptyMap $ \ys -&gt; Map.union (NonEmptyMap.flatten xs) (NonEmptyMap.flatten ys) == NonEmptyMap.flatten (NonEmptyMap.union xs ys)
--   </pre>

-- | <i>Warning: Dangerous because it silently drops colliding key/value
--   pairs. Better use unionWith.</i>
union :: Ord k => T k a -> T k a -> T k a

-- | <pre>
--   forAllMap $ \xm -&gt; forAllNonEmptyMap $ \ym -&gt; Map.union xm (NonEmptyMap.flatten ym) == NonEmptyMap.flatten (NonEmptyMap.unionLeft xm ym)
--   </pre>

-- | <i>Warning: Dangerous because it silently drops colliding key/value
--   pairs. Better use unionLeftWith.</i>
unionLeft :: Ord k => Map k a -> T k a -> T k a

-- | <pre>
--   forAllNonEmptyMap $ \xm -&gt; forAllMap $ \ym -&gt; Map.union (NonEmptyMap.flatten xm) ym == NonEmptyMap.flatten (NonEmptyMap.unionRight xm ym)
--   </pre>

-- | <i>Warning: Dangerous because it silently drops colliding key/value
--   pairs. Better use unionRightWith.</i>
unionRight :: Ord k => T k a -> Map k a -> T k a

-- | <pre>
--   forAllNonEmptyMap $ \xs -&gt; forAllNonEmptyMap $ \ys -&gt; Map.unionWith (++) (NonEmptyMap.flatten xs) (NonEmptyMap.flatten ys) == NonEmptyMap.flatten (NonEmptyMap.unionWith (++) xs ys)
--   </pre>
unionWith :: Ord k => (a -> a -> a) -> T k a -> T k a -> T k a

-- | <pre>
--   forAllMap $ \xm -&gt; forAllNonEmptyMap $ \ym -&gt; Map.unionWith (++) xm (NonEmptyMap.flatten ym) == NonEmptyMap.flatten (NonEmptyMap.unionLeftWith (++) xm ym)
--   </pre>
unionLeftWith :: Ord k => (a -> a -> a) -> Map k a -> T k a -> T k a

-- | <pre>
--   forAllNonEmptyMap $ \xm -&gt; forAllMap $ \ym -&gt; Map.unionWith (++) (NonEmptyMap.flatten xm) ym == NonEmptyMap.flatten (NonEmptyMap.unionRightWith (++) xm ym)
--   </pre>
unionRightWith :: Ord k => (a -> a -> a) -> T k a -> Map k a -> T k a
map :: Ord k => (a -> b) -> T k a -> T k b
mapWithKey :: Ord k => (k -> a -> b) -> T k a -> T k b
instance (GHC.Classes.Ord k, GHC.Classes.Ord a) => GHC.Classes.Ord (Data.NonEmpty.Map.T k a)
instance (GHC.Classes.Eq k, GHC.Classes.Eq a) => GHC.Classes.Eq (Data.NonEmpty.Map.T k a)
instance (GHC.Show.Show k, GHC.Show.Show a) => GHC.Show.Show (Data.NonEmpty.Map.T k a)
instance GHC.Classes.Ord k => GHC.Base.Functor (Data.NonEmpty.Map.T k)
instance GHC.Classes.Ord k => Data.Foldable.Foldable (Data.NonEmpty.Map.T k)
instance GHC.Classes.Ord k => Data.Traversable.Traversable (Data.NonEmpty.Map.T k)
instance (Control.DeepSeq.NFData k, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Data.NonEmpty.Map.T k a)
instance Control.DeepSeq.NFData k => Data.NonEmpty.Class.NFData (Data.NonEmpty.Map.T k)
instance (Test.QuickCheck.Arbitrary.Arbitrary k, GHC.Classes.Ord k, Test.QuickCheck.Arbitrary.Arbitrary a) => Test.QuickCheck.Arbitrary.Arbitrary (Data.NonEmpty.Map.T k a)
instance (Test.QuickCheck.Arbitrary.Arbitrary k, GHC.Classes.Ord k) => Data.NonEmpty.Class.Arbitrary (Data.NonEmpty.Map.T k)
instance (Test.QuickCheck.Arbitrary.Arbitrary k, GHC.Classes.Ord k) => Data.NonEmpty.Class.Gen (Data.NonEmpty.Map.T k)


-- | Word with fixed length lists constructed from <tt>NonEmpty</tt> and
--   <tt>Empty</tt> types.
module Data.FixedLengthList
type T0 = T
type T1 = T T0
type T2 = T T1
type T3 = T T2
type T4 = T T3
type T5 = T T4
type T6 = T T5
type T7 = T T6
type T8 = T T7
type T9 = T T8
type Func0 a b = b
type Func1 a b = a -> Func0 a b
type Func2 a b = a -> Func1 a b
type Func3 a b = a -> Func2 a b
type Func4 a b = a -> Func3 a b
type Func5 a b = a -> Func4 a b
type Func6 a b = a -> Func5 a b
type Func7 a b = a -> Func6 a b
type Func8 a b = a -> Func7 a b
type Func9 a b = a -> Func8 a b
uncurry0 :: Func0 a b -> T0 a -> b
uncurry1 :: Func1 a b -> T1 a -> b
uncurry2 :: Func2 a b -> T2 a -> b
uncurry3 :: Func3 a b -> T3 a -> b
uncurry4 :: Func4 a b -> T4 a -> b
uncurry5 :: Func5 a b -> T5 a -> b
uncurry6 :: Func6 a b -> T6 a -> b
uncurry7 :: Func7 a b -> T7 a -> b
uncurry8 :: Func8 a b -> T8 a -> b
uncurry9 :: Func9 a b -> T9 a -> b
curry0 :: (T0 a -> b) -> Func0 a b
curry1 :: (T1 a -> b) -> Func1 a b
curry2 :: (T2 a -> b) -> Func2 a b
curry3 :: (T3 a -> b) -> Func3 a b
curry4 :: (T4 a -> b) -> Func4 a b
curry5 :: (T5 a -> b) -> Func5 a b
curry6 :: (T6 a -> b) -> Func6 a b
curry7 :: (T7 a -> b) -> Func7 a b
curry8 :: (T8 a -> b) -> Func8 a b
curry9 :: (T9 a -> b) -> Func9 a b
consAll0 :: Func0 a (T0 a)
consAll1 :: Func1 a (T1 a)
consAll2 :: Func2 a (T2 a)
consAll3 :: Func3 a (T3 a)
consAll4 :: Func4 a (T4 a)
consAll5 :: Func5 a (T5 a)
consAll6 :: Func6 a (T6 a)
consAll7 :: Func7 a (T7 a)
consAll8 :: Func8 a (T8 a)
consAll9 :: Func9 a (T9 a)

module Data.Optional
data T f a
Nil :: T f a
Cons :: a -> f a -> T f a
(?:) :: a -> f a -> T f a
infixr 5 ?:
fromEmpty :: T a -> T f a
fromNonEmpty :: T f a -> T f a
instance (GHC.Classes.Ord a, GHC.Classes.Ord (f a)) => GHC.Classes.Ord (Data.Optional.T f a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq (f a)) => GHC.Classes.Eq (Data.Optional.T f a)
instance (Data.NonEmpty.Class.NFData f, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Data.Optional.T f a)
instance Data.NonEmpty.Class.NFData f => Data.NonEmpty.Class.NFData (Data.Optional.T f)
instance (Data.NonEmpty.Class.Show f, GHC.Show.Show a) => GHC.Show.Show (Data.Optional.T f a)
instance Data.NonEmpty.Class.Show f => Data.NonEmpty.Class.Show (Data.Optional.T f)
instance GHC.Base.Functor f => GHC.Base.Functor (Data.Optional.T f)
instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Data.Optional.T f)
instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Data.Optional.T f)
instance (Data.NonEmpty.Class.Arbitrary f, Test.QuickCheck.Arbitrary.Arbitrary a) => Test.QuickCheck.Arbitrary.Arbitrary (Data.Optional.T f a)
instance Data.NonEmpty.Class.Arbitrary f => Data.NonEmpty.Class.Arbitrary (Data.Optional.T f)
instance Data.NonEmpty.Class.Gen f => Data.NonEmpty.Class.Gen (Data.Optional.T f)
instance Data.NonEmpty.Class.Empty (Data.Optional.T f)
instance (Data.NonEmpty.Class.Cons f, Data.NonEmpty.Class.Empty f) => Data.NonEmpty.Class.Cons (Data.Optional.T f)
instance Data.NonEmpty.Class.Repeat f => Data.NonEmpty.Class.Repeat (Data.Optional.T f)
instance Data.NonEmpty.Class.Iterate f => Data.NonEmpty.Class.Iterate (Data.Optional.T f)
instance Data.NonEmpty.Class.Zip f => Data.NonEmpty.Class.Zip (Data.Optional.T f)
instance (Data.Traversable.Traversable f, Data.NonEmpty.Class.Reverse f) => Data.NonEmpty.Class.Reverse (Data.Optional.T f)
instance (Data.NonEmptyPrivate.Insert f, Data.NonEmpty.Class.Sort f) => Data.NonEmpty.Class.Sort (Data.Optional.T f)
instance (Data.NonEmptyPrivate.InsertBy f, Data.NonEmpty.Class.SortBy f) => Data.NonEmpty.Class.SortBy (Data.Optional.T f)
instance Data.NonEmptyPrivate.Insert f => Data.NonEmptyPrivate.Insert (Data.Optional.T f)
instance Data.NonEmptyPrivate.InsertBy f => Data.NonEmptyPrivate.InsertBy (Data.Optional.T f)

module Data.Zip

-- | Wrap a container such that its Applicative instance is based on zip.
newtype T f a
Cons :: f a -> T f a
[decons] :: T f a -> f a

-- | Always returns a rectangular list by clipping all dimensions to the
--   shortest slice. Be aware that <tt>transpose [] == repeat []</tt>.
transposeClip :: (Traversable f, Zip g, Repeat g) => f (g a) -> g (f a)
instance GHC.Base.Functor f => GHC.Base.Functor (Data.Zip.T f)
instance (Data.NonEmpty.Class.Zip f, Data.NonEmpty.Class.Repeat f) => GHC.Base.Applicative (Data.Zip.T f)
instance (Data.NonEmpty.Class.NFData f, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Data.Zip.T f a)
instance Data.NonEmpty.Class.NFData f => Data.NonEmpty.Class.NFData (Data.Zip.T f)