{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable, DeriveFunctor, DeriveTraversable #-}

-- | A 'Seq' that must contain at least one item.
module Data.Sequence.NonEmpty where

import Control.Monad (join, ap)
import Data.Data (Data)
import Data.Semigroup (Semigroup((<>)))
import Data.Sequence (Seq, (<|), ViewL(EmptyL, (:<)), viewl)
import Data.Typeable (Typeable)
import qualified Data.Sequence as Seq

-- | Conceptually this is a 'Seq' that always contains at least one item.
data NonEmptySeq a = NonEmptySeq
  { forall a. NonEmptySeq a -> a
_fore :: a
  , forall a. NonEmptySeq a -> Seq a
_aft :: Seq a
  } deriving (NonEmptySeq a -> NonEmptySeq a -> Bool
(NonEmptySeq a -> NonEmptySeq a -> Bool)
-> (NonEmptySeq a -> NonEmptySeq a -> Bool) -> Eq (NonEmptySeq a)
forall a. Eq a => NonEmptySeq a -> NonEmptySeq a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => NonEmptySeq a -> NonEmptySeq a -> Bool
== :: NonEmptySeq a -> NonEmptySeq a -> Bool
$c/= :: forall a. Eq a => NonEmptySeq a -> NonEmptySeq a -> Bool
/= :: NonEmptySeq a -> NonEmptySeq a -> Bool
Eq, Eq (NonEmptySeq a)
Eq (NonEmptySeq a) =>
(NonEmptySeq a -> NonEmptySeq a -> Ordering)
-> (NonEmptySeq a -> NonEmptySeq a -> Bool)
-> (NonEmptySeq a -> NonEmptySeq a -> Bool)
-> (NonEmptySeq a -> NonEmptySeq a -> Bool)
-> (NonEmptySeq a -> NonEmptySeq a -> Bool)
-> (NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a)
-> (NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a)
-> Ord (NonEmptySeq a)
NonEmptySeq a -> NonEmptySeq a -> Bool
NonEmptySeq a -> NonEmptySeq a -> Ordering
NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (NonEmptySeq a)
forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> Bool
forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> Ordering
forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a
$ccompare :: forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> Ordering
compare :: NonEmptySeq a -> NonEmptySeq a -> Ordering
$c< :: forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> Bool
< :: NonEmptySeq a -> NonEmptySeq a -> Bool
$c<= :: forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> Bool
<= :: NonEmptySeq a -> NonEmptySeq a -> Bool
$c> :: forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> Bool
> :: NonEmptySeq a -> NonEmptySeq a -> Bool
$c>= :: forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> Bool
>= :: NonEmptySeq a -> NonEmptySeq a -> Bool
$cmax :: forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a
max :: NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a
$cmin :: forall a. Ord a => NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a
min :: NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a
Ord, Int -> NonEmptySeq a -> ShowS
[NonEmptySeq a] -> ShowS
NonEmptySeq a -> String
(Int -> NonEmptySeq a -> ShowS)
-> (NonEmptySeq a -> String)
-> ([NonEmptySeq a] -> ShowS)
-> Show (NonEmptySeq a)
forall a. Show a => Int -> NonEmptySeq a -> ShowS
forall a. Show a => [NonEmptySeq a] -> ShowS
forall a. Show a => NonEmptySeq a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> NonEmptySeq a -> ShowS
showsPrec :: Int -> NonEmptySeq a -> ShowS
$cshow :: forall a. Show a => NonEmptySeq a -> String
show :: NonEmptySeq a -> String
$cshowList :: forall a. Show a => [NonEmptySeq a] -> ShowS
showList :: [NonEmptySeq a] -> ShowS
Show, Typeable (NonEmptySeq a)
Typeable (NonEmptySeq a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NonEmptySeq a -> c (NonEmptySeq a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NonEmptySeq a))
-> (NonEmptySeq a -> Constr)
-> (NonEmptySeq a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NonEmptySeq a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NonEmptySeq a)))
-> ((forall b. Data b => b -> b) -> NonEmptySeq a -> NonEmptySeq a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r)
-> (forall u. (forall d. Data d => d -> u) -> NonEmptySeq a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NonEmptySeq a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NonEmptySeq a -> m (NonEmptySeq a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NonEmptySeq a -> m (NonEmptySeq a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NonEmptySeq a -> m (NonEmptySeq a))
-> Data (NonEmptySeq a)
NonEmptySeq a -> Constr
NonEmptySeq a -> DataType
(forall b. Data b => b -> b) -> NonEmptySeq a -> NonEmptySeq a
forall a. Data a => Typeable (NonEmptySeq a)
forall a. Data a => NonEmptySeq a -> Constr
forall a. Data a => NonEmptySeq a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> NonEmptySeq a -> NonEmptySeq a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> NonEmptySeq a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> NonEmptySeq a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptySeq a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptySeq a -> c (NonEmptySeq a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmptySeq a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmptySeq a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NonEmptySeq a -> u
forall u. (forall d. Data d => d -> u) -> NonEmptySeq a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptySeq a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptySeq a -> c (NonEmptySeq a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmptySeq a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmptySeq a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptySeq a -> c (NonEmptySeq a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptySeq a -> c (NonEmptySeq a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptySeq a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptySeq a)
$ctoConstr :: forall a. Data a => NonEmptySeq a -> Constr
toConstr :: NonEmptySeq a -> Constr
$cdataTypeOf :: forall a. Data a => NonEmptySeq a -> DataType
dataTypeOf :: NonEmptySeq a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmptySeq a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmptySeq a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmptySeq a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmptySeq a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> NonEmptySeq a -> NonEmptySeq a
gmapT :: (forall b. Data b => b -> b) -> NonEmptySeq a -> NonEmptySeq a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptySeq a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> NonEmptySeq a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NonEmptySeq a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> NonEmptySeq a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NonEmptySeq a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NonEmptySeq a -> m (NonEmptySeq a)
Data, Typeable, (forall a b. (a -> b) -> NonEmptySeq a -> NonEmptySeq b)
-> (forall a b. a -> NonEmptySeq b -> NonEmptySeq a)
-> Functor NonEmptySeq
forall a b. a -> NonEmptySeq b -> NonEmptySeq a
forall a b. (a -> b) -> NonEmptySeq a -> NonEmptySeq b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> NonEmptySeq a -> NonEmptySeq b
fmap :: forall a b. (a -> b) -> NonEmptySeq a -> NonEmptySeq b
$c<$ :: forall a b. a -> NonEmptySeq b -> NonEmptySeq a
<$ :: forall a b. a -> NonEmptySeq b -> NonEmptySeq a
Functor, (forall m. Monoid m => NonEmptySeq m -> m)
-> (forall m a. Monoid m => (a -> m) -> NonEmptySeq a -> m)
-> (forall m a. Monoid m => (a -> m) -> NonEmptySeq a -> m)
-> (forall a b. (a -> b -> b) -> b -> NonEmptySeq a -> b)
-> (forall a b. (a -> b -> b) -> b -> NonEmptySeq a -> b)
-> (forall b a. (b -> a -> b) -> b -> NonEmptySeq a -> b)
-> (forall b a. (b -> a -> b) -> b -> NonEmptySeq a -> b)
-> (forall a. (a -> a -> a) -> NonEmptySeq a -> a)
-> (forall a. (a -> a -> a) -> NonEmptySeq a -> a)
-> (forall a. NonEmptySeq a -> [a])
-> (forall a. NonEmptySeq a -> Bool)
-> (forall a. NonEmptySeq a -> Int)
-> (forall a. Eq a => a -> NonEmptySeq a -> Bool)
-> (forall a. Ord a => NonEmptySeq a -> a)
-> (forall a. Ord a => NonEmptySeq a -> a)
-> (forall a. Num a => NonEmptySeq a -> a)
-> (forall a. Num a => NonEmptySeq a -> a)
-> Foldable NonEmptySeq
forall a. Eq a => a -> NonEmptySeq a -> Bool
forall a. Num a => NonEmptySeq a -> a
forall a. Ord a => NonEmptySeq a -> a
forall m. Monoid m => NonEmptySeq m -> m
forall a. NonEmptySeq a -> Bool
forall a. NonEmptySeq a -> Int
forall a. NonEmptySeq a -> [a]
forall a. (a -> a -> a) -> NonEmptySeq a -> a
forall m a. Monoid m => (a -> m) -> NonEmptySeq a -> m
forall b a. (b -> a -> b) -> b -> NonEmptySeq a -> b
forall a b. (a -> b -> b) -> b -> NonEmptySeq a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => NonEmptySeq m -> m
fold :: forall m. Monoid m => NonEmptySeq m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NonEmptySeq a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NonEmptySeq a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NonEmptySeq a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> NonEmptySeq a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> NonEmptySeq a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NonEmptySeq a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NonEmptySeq a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NonEmptySeq a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NonEmptySeq a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NonEmptySeq a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NonEmptySeq a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> NonEmptySeq a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> NonEmptySeq a -> a
foldr1 :: forall a. (a -> a -> a) -> NonEmptySeq a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NonEmptySeq a -> a
foldl1 :: forall a. (a -> a -> a) -> NonEmptySeq a -> a
$ctoList :: forall a. NonEmptySeq a -> [a]
toList :: forall a. NonEmptySeq a -> [a]
$cnull :: forall a. NonEmptySeq a -> Bool
null :: forall a. NonEmptySeq a -> Bool
$clength :: forall a. NonEmptySeq a -> Int
length :: forall a. NonEmptySeq a -> Int
$celem :: forall a. Eq a => a -> NonEmptySeq a -> Bool
elem :: forall a. Eq a => a -> NonEmptySeq a -> Bool
$cmaximum :: forall a. Ord a => NonEmptySeq a -> a
maximum :: forall a. Ord a => NonEmptySeq a -> a
$cminimum :: forall a. Ord a => NonEmptySeq a -> a
minimum :: forall a. Ord a => NonEmptySeq a -> a
$csum :: forall a. Num a => NonEmptySeq a -> a
sum :: forall a. Num a => NonEmptySeq a -> a
$cproduct :: forall a. Num a => NonEmptySeq a -> a
product :: forall a. Num a => NonEmptySeq a -> a
Foldable, Functor NonEmptySeq
Foldable NonEmptySeq
(Functor NonEmptySeq, Foldable NonEmptySeq) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> NonEmptySeq a -> f (NonEmptySeq b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    NonEmptySeq (f a) -> f (NonEmptySeq a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NonEmptySeq a -> m (NonEmptySeq b))
-> (forall (m :: * -> *) a.
    Monad m =>
    NonEmptySeq (m a) -> m (NonEmptySeq a))
-> Traversable NonEmptySeq
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
NonEmptySeq (m a) -> m (NonEmptySeq a)
forall (f :: * -> *) a.
Applicative f =>
NonEmptySeq (f a) -> f (NonEmptySeq a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NonEmptySeq a -> m (NonEmptySeq b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NonEmptySeq a -> f (NonEmptySeq b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NonEmptySeq a -> f (NonEmptySeq b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NonEmptySeq a -> f (NonEmptySeq b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
NonEmptySeq (f a) -> f (NonEmptySeq a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
NonEmptySeq (f a) -> f (NonEmptySeq a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NonEmptySeq a -> m (NonEmptySeq b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NonEmptySeq a -> m (NonEmptySeq b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
NonEmptySeq (m a) -> m (NonEmptySeq a)
sequence :: forall (m :: * -> *) a.
Monad m =>
NonEmptySeq (m a) -> m (NonEmptySeq a)
Traversable)

-- | van Laarhoven lens for the first element
fore :: Functor f => (a -> f a) -> NonEmptySeq a -> f (NonEmptySeq a)
fore :: forall (f :: * -> *) a.
Functor f =>
(a -> f a) -> NonEmptySeq a -> f (NonEmptySeq a)
fore a -> f a
inj (NonEmptySeq a
a1 Seq a
as) = (a -> Seq a -> NonEmptySeq a) -> Seq a -> a -> NonEmptySeq a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq Seq a
as (a -> NonEmptySeq a) -> f a -> f (NonEmptySeq a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f a
inj a
a1

-- | van Laarhoven lens for the remaining elements
aft :: Functor f => (Seq a -> f (Seq a)) -> NonEmptySeq a -> f (NonEmptySeq a)
aft :: forall (f :: * -> *) a.
Functor f =>
(Seq a -> f (Seq a)) -> NonEmptySeq a -> f (NonEmptySeq a)
aft Seq a -> f (Seq a)
inj (NonEmptySeq a
a1 Seq a
as) = a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq a
a1 (Seq a -> NonEmptySeq a) -> f (Seq a) -> f (NonEmptySeq a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Seq a -> f (Seq a)
inj Seq a
as

instance Semigroup (NonEmptySeq a) where
  (NonEmptySeq a
a1 Seq a
as) <> :: NonEmptySeq a -> NonEmptySeq a -> NonEmptySeq a
<> (NonEmptySeq a
b1 Seq a
bs)
    = a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq a
a1 (Seq a
as Seq a -> Seq a -> Seq a
forall a. Semigroup a => a -> a -> a
<> (a
b1 a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
<| Seq a
bs))

instance Monad NonEmptySeq where
  return :: forall a. a -> NonEmptySeq a
return a
a = a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq a
a Seq a
forall a. Seq a
Seq.empty
  NonEmptySeq a
a Seq a
as >>= :: forall a b. NonEmptySeq a -> (a -> NonEmptySeq b) -> NonEmptySeq b
>>= a -> NonEmptySeq b
f = b -> Seq b -> NonEmptySeq b
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq (NonEmptySeq b -> b
forall a. NonEmptySeq a -> a
_fore NonEmptySeq b
r1) Seq b
rs
    where
      r1 :: NonEmptySeq b
r1 = a -> NonEmptySeq b
f a
a
      rs :: Seq b
rs = NonEmptySeq b -> Seq b
forall a. NonEmptySeq a -> Seq a
_aft NonEmptySeq b
r1 Seq b -> Seq b -> Seq b
forall a. Monoid a => a -> a -> a
`mappend` Seq b
rss
      rss :: Seq b
rss = Seq (Seq b) -> Seq b
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (Seq (Seq b) -> Seq b) -> (Seq a -> Seq (Seq b)) -> Seq a -> Seq b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NonEmptySeq b -> Seq b) -> Seq (NonEmptySeq b) -> Seq (Seq b)
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NonEmptySeq b -> Seq b
forall a. NonEmptySeq a -> Seq a
nonEmptySeqToSeq (Seq (NonEmptySeq b) -> Seq (Seq b))
-> (Seq a -> Seq (NonEmptySeq b)) -> Seq a -> Seq (Seq b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> NonEmptySeq b) -> Seq a -> Seq (NonEmptySeq b)
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> NonEmptySeq b
f (Seq a -> Seq b) -> Seq a -> Seq b
forall a b. (a -> b) -> a -> b
$ Seq a
as

instance Applicative NonEmptySeq where
  pure :: forall a. a -> NonEmptySeq a
pure = a -> NonEmptySeq a
forall a. a -> NonEmptySeq a
forall (m :: * -> *) a. Monad m => a -> m a
return
  <*> :: forall a b. NonEmptySeq (a -> b) -> NonEmptySeq a -> NonEmptySeq b
(<*>) = NonEmptySeq (a -> b) -> NonEmptySeq a -> NonEmptySeq b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap

-- | Flattens a 'NonEmptySeq' to a 'Seq'.
nonEmptySeqToSeq :: NonEmptySeq a -> Seq a
nonEmptySeqToSeq :: forall a. NonEmptySeq a -> Seq a
nonEmptySeqToSeq (NonEmptySeq a
a1 Seq a
as) = a
a1 a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
<| Seq a
as

-- | If the 'Seq' has at least one item, create a 'NonEmptySeq'.
seqToNonEmptySeq :: Seq a -> Maybe (NonEmptySeq a)
seqToNonEmptySeq :: forall a. Seq a -> Maybe (NonEmptySeq a)
seqToNonEmptySeq Seq a
sq = case Seq a -> ViewL a
forall a. Seq a -> ViewL a
viewl Seq a
sq of
  ViewL a
EmptyL -> Maybe (NonEmptySeq a)
forall a. Maybe a
Nothing
  a
x :< Seq a
xs -> NonEmptySeq a -> Maybe (NonEmptySeq a)
forall a. a -> Maybe a
Just (a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq a
x Seq a
xs)

-- | Prepends a 'Seq' to a 'NonEmptySeq'.
prependSeq :: Seq a -> NonEmptySeq a -> NonEmptySeq a
prependSeq :: forall a. Seq a -> NonEmptySeq a -> NonEmptySeq a
prependSeq Seq a
sq (NonEmptySeq a
a Seq a
as) = case Seq a -> ViewL a
forall a. Seq a -> ViewL a
viewl Seq a
sq of
  ViewL a
EmptyL -> a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq a
a Seq a
as
  a
l :< Seq a
ls -> a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq a
l (Seq a
ls Seq a -> Seq a -> Seq a
forall a. Monoid a => a -> a -> a
`mappend` (a
a a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
<| Seq a
as))

-- | Appends a 'Seq' to a 'NonEmptySeq'.
appendSeq :: NonEmptySeq a -> Seq a -> NonEmptySeq a
appendSeq :: forall a. NonEmptySeq a -> Seq a -> NonEmptySeq a
appendSeq (NonEmptySeq a
a Seq a
as) Seq a
sq = a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq a
a (Seq a
as Seq a -> Seq a -> Seq a
forall a. Monoid a => a -> a -> a
`mappend` Seq a
sq)

-- | Place a single item at the head of the 'NonEmptySeq'.
singleton :: a -> NonEmptySeq a
singleton :: forall a. a -> NonEmptySeq a
singleton a
a = a -> Seq a -> NonEmptySeq a
forall a. a -> Seq a -> NonEmptySeq a
NonEmptySeq a
a Seq a
forall a. Seq a
Seq.empty