{-# LANGUAGE CPP                 #-}
{-# LANGUAGE DerivingVia         #-}
{-# LANGUAGE DeriveDataTypeable  #-}
{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE FlexibleContexts    #-}
{-# LANGUAGE LambdaCase          #-}
{-# LANGUAGE NoImplicitPrelude   #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies        #-}
{-# LANGUAGE TypeApplications    #-}
{-# LANGUAGE Trustworthy         #-}
{-# LANGUAGE RankNTypes          #-}
{-# LANGUAGE PatternSynonyms     #-}

{-|
NonEmpty - Like base's NonEmpty but with:

  * 'Show' and 'Read' instance similar to `[]`
  * A completely safe API
  * added\/removed\/updated functions


Added functions:

  * 'aNonEmpty'
  * `scanl'`
  * 'sortOn'
  * 'fromCons'

  * 'groupAll'
  * 'groupAllBy'
  * 'groupAll1'
  * 'groupAllBy1'

  * 'snoc'
  * 'unsnoc'

  * 'foldl1'   -- this family is present in base's 'Foldable1' from >= 4.18.0.0
  * `foldl1'`
  * 'foldr1'

Removed functions:

  * 'NE.unzip'  (not nonempty-specific)
  * 'NE.unfold' (deprecated, use unfoldr)
  * 'NE.xor'    (seemed out of place)


Changed functions:

  * 'uncons'


Replaced functions:

  * s/(!!)/(!?)/
-}

module Data.List.NeoNonEmpty
  (
  -- * Construction
    NonEmpty
  , pattern (:|)
  , singleton
  , fromCons

  -- * Type annotations
  , aNonEmpty

  -- * Converting to and from base's 'NE.NonEmpty'
  , fromNonEmpty
  , toNonEmpty

  -- * Converting to and from lists
  , fromList
  , toList

  -- * Basic functions
  , length
  , head
  , tail
  , last
  , init
  , cons
  , uncons
  , snoc
  , unsnoc
  , unfoldr
  , sort
  , reverse
  , inits
  , inits1
  , tails
  , tails1
  , append
  , appendList
  , prependList

  -- * Stream transformations
  , map
  , intersperse
  , foldl1
  , foldl1'
  , foldr1
  , scanl
  , scanl'
  , scanl1
  , scanr
  , scanr1
  , transpose
  , sortBy
  , sortOn
  , sortWith

  -- * Building streams
  , iterate
  , repeat
  , cycle
  , insert
  , some1

  -- * Extracting sublists
  , take
  , drop
  , splitAt
  , takeWhile
  , dropWhile
  , span
  , break
  , filter
  , partition
  , group
  , groupAll
  , groupBy
  , groupAllBy
  , groupWith
  , groupAllWith
  , group1
  , groupAll1
  , groupBy1
  , groupAllBy1
  , groupWith1
  , groupAllWith1

  -- * Sublist predicates
  , isPrefixOf

  -- * "Set" operations
  , nub
  , nubBy

  -- * Indexing streams
  , (!?)

  -- * Zipping streams
  , zip
  , zipWith
  ) where

import Prelude
  ( Bool
  , Applicative(..)
  , Eq(..)
  , Foldable
  , Functor(..)
  , Int
  , Maybe(..)
  , Monad(..)
  , Ord(..)
  , Ordering(..)
  , Semigroup
  , Show(..)
  , ($)
  , (.)
  , (++)
  , fail
  , otherwise
  )

import Control.Applicative             (Alternative)
import Control.Monad.Fix               (MonadFix)
import Control.Monad.Zip               (MonadZip)
import Data.Bifunctor                  (first)
import Data.Data                       (Data)
#if MIN_VERSION_base(4,18,0)
import Data.Foldable1                  (Foldable1)
#endif
import Data.Functor.Classes            (Eq1, Ord1, Read1, Show1)
import Data.Maybe                      (fromJust, listToMaybe)
import Data.Tuple                      (swap)
import GHC.Generics                    (Generic, Generic1)
import Text.Read                       (Read(..))

import qualified Data.Foldable             as Foldable
import qualified Data.List                 as List
#if (MIN_VERSION_base_compat(0,10,1))
import qualified Data.List.NonEmpty.Compat as NE
#else
import qualified Data.List.NonEmpty        as NE
#endif
import qualified GHC.Exts                  as Exts


-- * Instances

instance Exts.IsList (NonEmpty a) where
  type Item (NonEmpty a) = a
  fromList :: [Item (NonEmpty a)] -> NonEmpty a
fromList = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty (NonEmpty a -> NonEmpty a)
-> ([a] -> NonEmpty a) -> [a] -> NonEmpty a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> NonEmpty a
[Item (NonEmpty a)] -> NonEmpty a
forall l. IsList l => [Item l] -> l
Exts.fromList
  toList :: NonEmpty a -> [Item (NonEmpty a)]
toList (NonEmpty NonEmpty a
l) = NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty a
l

instance Show a => Show (NonEmpty a) where
  show :: NonEmpty a -> String
show (NonEmpty NonEmpty a
l) = [a] -> String
forall a. Show a => a -> String
show (NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty a
l)

instance Read a => Read (NonEmpty a) where
  readPrec :: ReadPrec (NonEmpty a)
readPrec = ReadPrec [a]
forall a. Read a => ReadPrec a
readPrec ReadPrec [a]
-> ([a] -> ReadPrec (NonEmpty a)) -> ReadPrec (NonEmpty a)
forall a b. ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    (a
x : [a]
xs) -> NonEmpty a -> ReadPrec (NonEmpty a)
forall a. a -> ReadPrec a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NonEmpty a -> ReadPrec (NonEmpty a))
-> NonEmpty a -> ReadPrec (NonEmpty a)
forall a b. (a -> b) -> a -> b
$ NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (a -> b) -> a -> b
$ a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
NE.:| [a]
xs
    [] -> String -> ReadPrec (NonEmpty a)
forall a. String -> ReadPrec a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Can't read NonEmpty list with zero elements"


-- * Construction

-- | A list with one or more elements.
newtype NonEmpty a = NonEmpty (NE.NonEmpty a)
  deriving ((forall x. NonEmpty a -> Rep (NonEmpty a) x)
-> (forall x. Rep (NonEmpty a) x -> NonEmpty a)
-> Generic (NonEmpty a)
forall x. Rep (NonEmpty a) x -> NonEmpty a
forall x. NonEmpty a -> Rep (NonEmpty a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (NonEmpty a) x -> NonEmpty a
forall a x. NonEmpty a -> Rep (NonEmpty a) x
$cfrom :: forall a x. NonEmpty a -> Rep (NonEmpty a) x
from :: forall x. NonEmpty a -> Rep (NonEmpty a) x
$cto :: forall a x. Rep (NonEmpty a) x -> NonEmpty a
to :: forall x. Rep (NonEmpty a) x -> NonEmpty a
Generic, (forall a. NonEmpty a -> Rep1 NonEmpty a)
-> (forall a. Rep1 NonEmpty a -> NonEmpty a) -> Generic1 NonEmpty
forall a. Rep1 NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> Rep1 NonEmpty a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. NonEmpty a -> Rep1 NonEmpty a
from1 :: forall a. NonEmpty a -> Rep1 NonEmpty a
$cto1 :: forall a. Rep1 NonEmpty a -> NonEmpty a
to1 :: forall a. Rep1 NonEmpty a -> NonEmpty a
Generic1, Typeable (NonEmpty a)
Typeable (NonEmpty a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NonEmpty a))
-> (NonEmpty a -> Constr)
-> (NonEmpty a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NonEmpty a)))
-> ((forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r)
-> (forall u. (forall d. Data d => d -> u) -> NonEmpty a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a))
-> Data (NonEmpty a)
NonEmpty a -> Constr
NonEmpty a -> DataType
(forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a
forall {a}. Data a => Typeable (NonEmpty a)
forall a. Data a => NonEmpty a -> Constr
forall a. Data a => NonEmpty a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> NonEmpty a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmpty a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmpty 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) -> NonEmpty a -> u
forall u. (forall d. Data d => d -> u) -> NonEmpty a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmpty a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmpty a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmpty a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmpty a)
$ctoConstr :: forall a. Data a => NonEmpty a -> Constr
toConstr :: NonEmpty a -> Constr
$cdataTypeOf :: forall a. Data a => NonEmpty a -> DataType
dataTypeOf :: NonEmpty a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmpty a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmpty a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a
gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> NonEmpty a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NonEmpty a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a)
Data)
  deriving
    ( Functor NonEmpty
Functor NonEmpty
-> (forall a. a -> NonEmpty a)
-> (forall a b. NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b)
-> (forall a b c.
    (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c)
-> (forall a b. NonEmpty a -> NonEmpty b -> NonEmpty b)
-> (forall a b. NonEmpty a -> NonEmpty b -> NonEmpty a)
-> Applicative NonEmpty
forall a. a -> NonEmpty a
forall a b. NonEmpty a -> NonEmpty b -> NonEmpty a
forall a b. NonEmpty a -> NonEmpty b -> NonEmpty b
forall a b. NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b
forall a b c.
(a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> NonEmpty a
pure :: forall a. a -> NonEmpty a
$c<*> :: forall a b. NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b
<*> :: forall a b. NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b
$cliftA2 :: forall a b c.
(a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
liftA2 :: forall a b c.
(a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
$c*> :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty b
*> :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty b
$c<* :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty a
<* :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty a
Applicative
    , (forall a b. (a -> b) -> NonEmpty a -> NonEmpty b)
-> (forall a b. a -> NonEmpty b -> NonEmpty a) -> Functor NonEmpty
forall a b. a -> NonEmpty b -> NonEmpty a
forall a b. (a -> b) -> NonEmpty a -> NonEmpty 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) -> NonEmpty a -> NonEmpty b
fmap :: forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
$c<$ :: forall a b. a -> NonEmpty b -> NonEmpty a
<$ :: forall a b. a -> NonEmpty b -> NonEmpty a
Functor
    , Monad NonEmpty
Monad NonEmpty
-> (forall a. (a -> NonEmpty a) -> NonEmpty a) -> MonadFix NonEmpty
forall a. (a -> NonEmpty a) -> NonEmpty a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
$cmfix :: forall a. (a -> NonEmpty a) -> NonEmpty a
mfix :: forall a. (a -> NonEmpty a) -> NonEmpty a
MonadFix
    , Monad NonEmpty
Monad NonEmpty
-> (forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b))
-> (forall a b c.
    (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c)
-> (forall a b. NonEmpty (a, b) -> (NonEmpty a, NonEmpty b))
-> MonadZip NonEmpty
forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
forall a b. NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
forall a b c.
(a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
forall (m :: * -> *).
Monad m
-> (forall a b. m a -> m b -> m (a, b))
-> (forall a b c. (a -> b -> c) -> m a -> m b -> m c)
-> (forall a b. m (a, b) -> (m a, m b))
-> MonadZip m
$cmzip :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
mzip :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
$cmzipWith :: forall a b c.
(a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
mzipWith :: forall a b c.
(a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
$cmunzip :: forall a b. NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
munzip :: forall a b. NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
MonadZip
    , (forall m. Monoid m => NonEmpty m -> m)
-> (forall m a. Monoid m => (a -> m) -> NonEmpty a -> m)
-> (forall m a. Monoid m => (a -> m) -> NonEmpty a -> m)
-> (forall a b. (a -> b -> b) -> b -> NonEmpty a -> b)
-> (forall a b. (a -> b -> b) -> b -> NonEmpty a -> b)
-> (forall b a. (b -> a -> b) -> b -> NonEmpty a -> b)
-> (forall b a. (b -> a -> b) -> b -> NonEmpty a -> b)
-> (forall a. (a -> a -> a) -> NonEmpty a -> a)
-> (forall a. (a -> a -> a) -> NonEmpty a -> a)
-> (forall a. NonEmpty a -> [a])
-> (forall a. NonEmpty a -> Bool)
-> (forall a. NonEmpty a -> Int)
-> (forall a. Eq a => a -> NonEmpty a -> Bool)
-> (forall a. Ord a => NonEmpty a -> a)
-> (forall a. Ord a => NonEmpty a -> a)
-> (forall a. Num a => NonEmpty a -> a)
-> (forall a. Num a => NonEmpty a -> a)
-> Foldable NonEmpty
forall a. Eq a => a -> NonEmpty a -> Bool
forall a. Num a => NonEmpty a -> a
forall a. Ord a => NonEmpty a -> a
forall m. Monoid m => NonEmpty m -> m
forall a. NonEmpty a -> Bool
forall a. NonEmpty a -> Int
forall a. NonEmpty a -> [a]
forall a. (a -> a -> a) -> NonEmpty a -> a
forall m a. Monoid m => (a -> m) -> NonEmpty a -> m
forall b a. (b -> a -> b) -> b -> NonEmpty a -> b
forall a b. (a -> b -> b) -> b -> NonEmpty 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 => NonEmpty m -> m
fold :: forall m. Monoid m => NonEmpty m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NonEmpty a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NonEmpty a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NonEmpty a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> NonEmpty a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> NonEmpty a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NonEmpty a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NonEmpty a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NonEmpty a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NonEmpty a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NonEmpty a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NonEmpty a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> NonEmpty a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> NonEmpty a -> a
foldr1 :: forall a. (a -> a -> a) -> NonEmpty a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NonEmpty a -> a
foldl1 :: forall a. (a -> a -> a) -> NonEmpty a -> a
$ctoList :: forall a. NonEmpty a -> [a]
toList :: forall a. NonEmpty a -> [a]
$cnull :: forall a. NonEmpty a -> Bool
null :: forall a. NonEmpty a -> Bool
$clength :: forall a. NonEmpty a -> Int
length :: forall a. NonEmpty a -> Int
$celem :: forall a. Eq a => a -> NonEmpty a -> Bool
elem :: forall a. Eq a => a -> NonEmpty a -> Bool
$cmaximum :: forall a. Ord a => NonEmpty a -> a
maximum :: forall a. Ord a => NonEmpty a -> a
$cminimum :: forall a. Ord a => NonEmpty a -> a
minimum :: forall a. Ord a => NonEmpty a -> a
$csum :: forall a. Num a => NonEmpty a -> a
sum :: forall a. Num a => NonEmpty a -> a
$cproduct :: forall a. Num a => NonEmpty a -> a
product :: forall a. Num a => NonEmpty a -> a
Foldable
#if MIN_VERSION_base(4,18,0)
    , Foldable1
#endif
    , (forall a b. (a -> b -> Bool) -> NonEmpty a -> NonEmpty b -> Bool)
-> Eq1 NonEmpty
forall a b. (a -> b -> Bool) -> NonEmpty a -> NonEmpty b -> Bool
forall (f :: * -> *).
(forall a b. (a -> b -> Bool) -> f a -> f b -> Bool) -> Eq1 f
$cliftEq :: forall a b. (a -> b -> Bool) -> NonEmpty a -> NonEmpty b -> Bool
liftEq :: forall a b. (a -> b -> Bool) -> NonEmpty a -> NonEmpty b -> Bool
Eq1
    , Eq1 NonEmpty
Eq1 NonEmpty
-> (forall a b.
    (a -> b -> Ordering) -> NonEmpty a -> NonEmpty b -> Ordering)
-> Ord1 NonEmpty
forall a b.
(a -> b -> Ordering) -> NonEmpty a -> NonEmpty b -> Ordering
forall (f :: * -> *).
Eq1 f
-> (forall a b. (a -> b -> Ordering) -> f a -> f b -> Ordering)
-> Ord1 f
$cliftCompare :: forall a b.
(a -> b -> Ordering) -> NonEmpty a -> NonEmpty b -> Ordering
liftCompare :: forall a b.
(a -> b -> Ordering) -> NonEmpty a -> NonEmpty b -> Ordering
Ord1
    , (forall a.
 (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a))
-> (forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a])
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a))
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a])
-> Read1 NonEmpty
forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a]
forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a)
forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a]
forall (f :: * -> *).
(forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a))
-> (forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [f a])
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (f a))
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [f a])
-> Read1 f
$cliftReadsPrec :: forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a)
liftReadsPrec :: forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmpty a)
$cliftReadList :: forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a]
liftReadList :: forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmpty a]
$cliftReadPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a)
liftReadPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmpty a)
$cliftReadListPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a]
liftReadListPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmpty a]
Read1
    , (forall a.
 (Int -> a -> ShowS)
 -> ([a] -> ShowS) -> Int -> NonEmpty a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [NonEmpty a] -> ShowS)
-> Show1 NonEmpty
forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NonEmpty a -> ShowS
forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> [NonEmpty a] -> ShowS
forall (f :: * -> *).
(forall a.
 (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS)
-> Show1 f
$cliftShowsPrec :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NonEmpty a -> ShowS
liftShowsPrec :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NonEmpty a -> ShowS
$cliftShowList :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> [NonEmpty a] -> ShowS
liftShowList :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> [NonEmpty a] -> ShowS
Show1
    , Applicative NonEmpty
Applicative NonEmpty
-> (forall a b. NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b)
-> (forall a b. NonEmpty a -> NonEmpty b -> NonEmpty b)
-> (forall a. a -> NonEmpty a)
-> Monad NonEmpty
forall a. a -> NonEmpty a
forall a b. NonEmpty a -> NonEmpty b -> NonEmpty b
forall a b. NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall a b. NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b
>>= :: forall a b. NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b
$c>> :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty b
>> :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty b
$creturn :: forall a. a -> NonEmpty a
return :: forall a. a -> NonEmpty a
Monad
    ) via NE.NonEmpty
  deriving
    ( NonEmpty a -> NonEmpty a -> Bool
(NonEmpty a -> NonEmpty a -> Bool)
-> (NonEmpty a -> NonEmpty a -> Bool) -> Eq (NonEmpty a)
forall a. Eq a => NonEmpty a -> NonEmpty a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => NonEmpty a -> NonEmpty a -> Bool
== :: NonEmpty a -> NonEmpty a -> Bool
$c/= :: forall a. Eq a => NonEmpty a -> NonEmpty a -> Bool
/= :: NonEmpty a -> NonEmpty a -> Bool
Eq
    , Eq (NonEmpty a)
Eq (NonEmpty a)
-> (NonEmpty a -> NonEmpty a -> Ordering)
-> (NonEmpty a -> NonEmpty a -> Bool)
-> (NonEmpty a -> NonEmpty a -> Bool)
-> (NonEmpty a -> NonEmpty a -> Bool)
-> (NonEmpty a -> NonEmpty a -> Bool)
-> (NonEmpty a -> NonEmpty a -> NonEmpty a)
-> (NonEmpty a -> NonEmpty a -> NonEmpty a)
-> Ord (NonEmpty a)
NonEmpty a -> NonEmpty a -> Bool
NonEmpty a -> NonEmpty a -> Ordering
NonEmpty a -> NonEmpty a -> NonEmpty 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 (NonEmpty a)
forall a. Ord a => NonEmpty a -> NonEmpty a -> Bool
forall a. Ord a => NonEmpty a -> NonEmpty a -> Ordering
forall a. Ord a => NonEmpty a -> NonEmpty a -> NonEmpty a
$ccompare :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Ordering
compare :: NonEmpty a -> NonEmpty a -> Ordering
$c< :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Bool
< :: NonEmpty a -> NonEmpty a -> Bool
$c<= :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Bool
<= :: NonEmpty a -> NonEmpty a -> Bool
$c> :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Bool
> :: NonEmpty a -> NonEmpty a -> Bool
$c>= :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Bool
>= :: NonEmpty a -> NonEmpty a -> Bool
$cmax :: forall a. Ord a => NonEmpty a -> NonEmpty a -> NonEmpty a
max :: NonEmpty a -> NonEmpty a -> NonEmpty a
$cmin :: forall a. Ord a => NonEmpty a -> NonEmpty a -> NonEmpty a
min :: NonEmpty a -> NonEmpty a -> NonEmpty a
Ord
    , NonEmpty (NonEmpty a) -> NonEmpty a
NonEmpty a -> NonEmpty a -> NonEmpty a
(NonEmpty a -> NonEmpty a -> NonEmpty a)
-> (NonEmpty (NonEmpty a) -> NonEmpty a)
-> (forall b. Integral b => b -> NonEmpty a -> NonEmpty a)
-> Semigroup (NonEmpty a)
forall b. Integral b => b -> NonEmpty a -> NonEmpty a
forall a. NonEmpty (NonEmpty a) -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a -> NonEmpty a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> NonEmpty a -> NonEmpty a
$c<> :: forall a. NonEmpty a -> NonEmpty a -> NonEmpty a
<> :: NonEmpty a -> NonEmpty a -> NonEmpty a
$csconcat :: forall a. NonEmpty (NonEmpty a) -> NonEmpty a
sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a
$cstimes :: forall a b. Integral b => b -> NonEmpty a -> NonEmpty a
stimes :: forall b. Integral b => b -> NonEmpty a -> NonEmpty a
Semigroup
    ) via (NE.NonEmpty a)

{-# COMPLETE (:|) #-}
-- | Construct a NonEmpty from an element and a list.
pattern (:|) :: a -> [a] -> NonEmpty a
pattern x $m:| :: forall {r} {a}. NonEmpty a -> (a -> [a] -> r) -> ((# #) -> r) -> r
$b:| :: forall a. a -> [a] -> NonEmpty a
:| xs <- NonEmpty (x NE.:| xs) where
  a
x :| [a]
xs = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty (a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
NE.:| [a]
xs)

-- | Construct a NonEmpty list from a single element.
singleton :: a -> NonEmpty a
singleton :: forall a. a -> NonEmpty a
singleton a
a = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty (a
a a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
NE.:| [])

-- | Construct a 'NonEmpty' from an element and a list.
fromCons :: a -> [a] -> NonEmpty a
fromCons :: forall a. a -> [a] -> NonEmpty a
fromCons a
x [a]
xs = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty (a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
NE.:| [a]
xs)


-- * Unsafe utilities, not exported

onUnderlying
  :: forall a b c d. (Exts.Coercible (NonEmpty c) a, Exts.Coercible b (NonEmpty d))
  => (a -> b)
  -> NonEmpty c -> NonEmpty d
onUnderlying :: forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying a -> b
f = b -> NonEmpty d
forall a b. Coercible a b => a -> b
Exts.coerce (b -> NonEmpty d) -> (NonEmpty c -> b) -> NonEmpty c -> NonEmpty d
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f (a -> b) -> (NonEmpty c -> a) -> NonEmpty c -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty c -> a
forall a b. Coercible a b => a -> b
Exts.coerce

onNonEmpty :: (NE.NonEmpty a -> NE.NonEmpty b) -> NonEmpty a -> NonEmpty b
onNonEmpty :: forall a b. (NonEmpty a -> NonEmpty b) -> NonEmpty a -> NonEmpty b
onNonEmpty = (NonEmpty a -> NonEmpty b) -> NonEmpty a -> NonEmpty b
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying

-- Unsafe. Not exported.
unsafeFromList :: [a] -> NonEmpty a
unsafeFromList :: forall a. [a] -> NonEmpty a
unsafeFromList = Maybe (NonEmpty a) -> NonEmpty a
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (NonEmpty a) -> NonEmpty a)
-> ([a] -> Maybe (NonEmpty a)) -> [a] -> NonEmpty a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Maybe (NonEmpty a)
forall a. [a] -> Maybe (NonEmpty a)
fromList

-- Unsafe. Not exported.
onList :: ([a] -> [b]) -> NonEmpty a -> NonEmpty b
onList :: forall a b. ([a] -> [b]) -> NonEmpty a -> NonEmpty b
onList [a] -> [b]
f = [b] -> NonEmpty b
forall a. [a] -> NonEmpty a
unsafeFromList ([b] -> NonEmpty b)
-> (NonEmpty a -> [b]) -> NonEmpty a -> NonEmpty b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [b]
f ([a] -> [b]) -> (NonEmpty a -> [a]) -> NonEmpty a -> [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
toList


-- * Type annotations

-- | A non empty thing. Useful as a syntactically lightweight type annotation,
-- especially when using OverloadedLists:
--
-- >>> :set -XOverloadedLists
-- >>> [(), ()]
--     • Ambiguous type variable ‘a0’ arising from a use of ‘print’
--       prevents the constraint ‘(Show a0)’ from being solved.
-- >>> aNonEmpty [(), ()]
-- [(),()]
aNonEmpty :: NonEmpty a -> NonEmpty a
aNonEmpty :: forall a. NonEmpty a -> NonEmpty a
aNonEmpty NonEmpty a
a = NonEmpty a
a


-- * Converting to and from nonempties

-- | Converts base's 'NE.NonEmpty' to a 'NonEmpty'
fromNonEmpty :: NE.NonEmpty a -> NonEmpty a
fromNonEmpty :: forall a. NonEmpty a -> NonEmpty a
fromNonEmpty = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty

-- | Converts a 'NonEmpty' to base's 'NonEmpty'
toNonEmpty :: NonEmpty a -> NE.NonEmpty a
toNonEmpty :: forall a. NonEmpty a -> NonEmpty a
toNonEmpty (NonEmpty NonEmpty a
ne) = NonEmpty a
ne


-- * Converting to and from lists

-- | Converts a normal list to a NonEmpty list, given the list has at least one element
fromList :: [a] -> Maybe (NonEmpty a)
fromList :: forall a. [a] -> Maybe (NonEmpty a)
fromList (a
x : [a]
xs) = NonEmpty a -> Maybe (NonEmpty a)
forall a. a -> Maybe a
Just (a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
fromCons a
x [a]
xs)
fromList [] = Maybe (NonEmpty a)
forall a. Maybe a
Nothing

-- | Converts a 'NonEmpty' list to a normal list
toList :: NonEmpty a -> [a]
toList :: forall a. NonEmpty a -> [a]
toList (NonEmpty NonEmpty a
ne) = NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty a
ne


-- * Basic functions

-- | Number of elements in NonEmpty list.
length :: NonEmpty a -> Int
length :: forall a. NonEmpty a -> Int
length = NonEmpty a -> Int
forall a. NonEmpty a -> Int
NE.length (NonEmpty a -> Int)
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Extract the first element of the nonempty stream.
head :: NonEmpty a -> a
head :: forall a. NonEmpty a -> a
head = NonEmpty a -> a
forall a. NonEmpty a -> a
NE.head (NonEmpty a -> a) -> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Extract the possibly-empty tail of the nonempty stream.
tail :: NonEmpty a -> [a]
tail :: forall a. NonEmpty a -> [a]
tail = NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.tail (NonEmpty a -> [a])
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Extract the last element of the nonempty stream.
last :: NonEmpty a -> a
last :: forall a. NonEmpty a -> a
last = NonEmpty a -> a
forall a. NonEmpty a -> a
NE.last (NonEmpty a -> a) -> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Extract everything except the last element of the nonempty stream.
init :: NonEmpty a -> [a]
init :: forall a. NonEmpty a -> [a]
init = NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.init (NonEmpty a -> [a])
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Prepend an element to the nonempty stream.
cons :: a -> NonEmpty a -> NonEmpty a
cons :: forall a. a -> NonEmpty a -> NonEmpty a
cons a
el = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying (a -> NonEmpty a -> NonEmpty a
forall a. a -> NonEmpty a -> NonEmpty a
NE.cons a
el)

-- | Produces the first element of the nonempty stream,
-- and a stream of the remaining elements.
uncons :: NonEmpty a -> (a, [a])
uncons :: forall a. NonEmpty a -> (a, [a])
uncons (NonEmpty (a
x NE.:| [a]
xs)) = (a
x, [a]
xs)

-- | Append an element to the back of a nonempty stream.
snoc :: NonEmpty a -> a -> NonEmpty a
snoc :: forall a. NonEmpty a -> a -> NonEmpty a
snoc NonEmpty a
l a
el = NonEmpty a
l NonEmpty a -> NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a -> NonEmpty a
`append` a -> NonEmpty a
forall a. a -> NonEmpty a
singleton a
el

-- | Produces all elements up to the last element, and the last element
unsnoc :: forall a. NonEmpty a -> ([a], a)
unsnoc :: forall a. NonEmpty a -> ([a], a)
unsnoc = ([a] -> [a]) -> ([a], a) -> ([a], a)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first [a] -> [a]
forall a. [a] -> [a]
List.reverse (([a], a) -> ([a], a))
-> (NonEmpty a -> ([a], a)) -> NonEmpty a -> ([a], a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, [a]) -> ([a], a)
forall a b. (a, b) -> (b, a)
swap ((a, [a]) -> ([a], a))
-> (NonEmpty a -> (a, [a])) -> NonEmpty a -> ([a], a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> (a, [a])
forall a. NonEmpty a -> (a, [a])
uncons (NonEmpty a -> (a, [a]))
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> (a, [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
reverse

-- | Dual of 'foldr', see 'List.unfoldr'.
unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b
unfoldr :: forall a b. (a -> (b, Maybe a)) -> a -> NonEmpty b
unfoldr a -> (b, Maybe a)
f a
initial = NonEmpty b -> NonEmpty b
forall a. NonEmpty a -> NonEmpty a
fromNonEmpty (NonEmpty b -> NonEmpty b) -> NonEmpty b -> NonEmpty b
forall a b. (a -> b) -> a -> b
$ (a -> (b, Maybe a)) -> a -> NonEmpty b
forall a b. (a -> (b, Maybe a)) -> a -> NonEmpty b
NE.unfoldr a -> (b, Maybe a)
f a
initial

-- | Sort a nonempty stream.
sort :: forall a. Ord a => NonEmpty a -> NonEmpty a
sort :: forall a. Ord a => NonEmpty a -> NonEmpty a
sort = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (NonEmpty a -> NonEmpty b) -> NonEmpty a -> NonEmpty b
onNonEmpty NonEmpty a -> NonEmpty a
forall a. Ord a => NonEmpty a -> NonEmpty a
NE.sort

-- | Reverse a nonempty stream.
reverse :: NonEmpty a -> NonEmpty a
reverse :: forall a. NonEmpty a -> NonEmpty a
reverse = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (NonEmpty a -> NonEmpty b) -> NonEmpty a -> NonEmpty b
onNonEmpty NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NE.reverse

-- | Produces all the prefixes of a stream, starting with the shortest.
-- The result is 'NonEmpty' because the result always contains the empty list as
-- the first element.
--
-- >>> inits [1,2,3] 
-- [[], [1], [1,2], [1,2,3]]
--
-- >>> inits [1]
-- [[], [1]]
--
-- >>> inits []
-- [[]]
inits :: Foldable f => f a -> NonEmpty [a] 
inits :: forall (f :: * -> *) a. Foldable f => f a -> NonEmpty [a]
inits = [[a]] -> NonEmpty [a]
forall a. [a] -> NonEmpty a
unsafeFromList ([[a]] -> NonEmpty [a]) -> (f a -> [[a]]) -> f a -> NonEmpty [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [[a]]
forall a. [a] -> [[a]]
List.inits ([a] -> [[a]]) -> (f a -> [a]) -> f a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Foldable.toList


-- | Produces all the nonempty prefixes of a nonempty stream, starting with the shortest.
--
-- >>> inits1 [1,2,3]
-- [[1], [1,2], [1,2,3]]
--
-- >>> inits1 [1]
-- [[1]]
inits1 :: forall a. NonEmpty a -> NonEmpty (NonEmpty a) 
# if (MIN_VERSION_base(4,18,0)) || (MIN_VERSION_base_compat(0,13,1))
inits1 = onUnderlying @_ @(NE.NonEmpty (NE.NonEmpty a)) NE.inits1
#else
inits1 :: forall a. NonEmpty a -> NonEmpty (NonEmpty a)
inits1 = [NonEmpty a] -> NonEmpty (NonEmpty a)
forall a. [a] -> NonEmpty a
unsafeFromList ([NonEmpty a] -> NonEmpty (NonEmpty a))
-> (NonEmpty a -> [NonEmpty a])
-> NonEmpty a
-> NonEmpty (NonEmpty a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([a] -> NonEmpty a) -> [[a]] -> [NonEmpty a]
forall a b. (a -> b) -> [a] -> [b]
List.map [a] -> NonEmpty a
forall a. [a] -> NonEmpty a
unsafeFromList ([[a]] -> [NonEmpty a])
-> (NonEmpty a -> [[a]]) -> NonEmpty a -> [NonEmpty a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[a]] -> [[a]]
forall a. HasCallStack => [a] -> [a]
List.tail ([[a]] -> [[a]]) -> (NonEmpty a -> [[a]]) -> NonEmpty a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [[a]]
forall a. [a] -> [[a]]
List.inits ([a] -> [[a]]) -> (NonEmpty a -> [a]) -> NonEmpty a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
toList
# endif

-- | Produces all the suffixes of a stream, starting with the longest.
-- The result is 'NonEmpty' because the result always contains the empty list as
-- the first element.
--
-- >>> tails [1,2,3]
-- [[1, 2, 3], [2, 3], [3], []]
--
-- >>> tails [1]
-- [[1], []]
--
-- >>> tails []
-- [[]]
tails :: Foldable f => f a -> NonEmpty [a]
tails :: forall (f :: * -> *) a. Foldable f => f a -> NonEmpty [a]
tails = NonEmpty [a] -> NonEmpty [a]
forall a. NonEmpty a -> NonEmpty a
fromNonEmpty (NonEmpty [a] -> NonEmpty [a])
-> (f a -> NonEmpty [a]) -> f a -> NonEmpty [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> NonEmpty [a]
forall (f :: * -> *) a. Foldable f => f a -> NonEmpty [a]
NE.tails

-- | Produces all the nonempty suffixes of a nonempty stream, starting with the longest.
--
-- >>> tails1 [1,2,3]
-- [[1, 2, 3], [2, 3], [3]]
--
-- >>> tails1 [1]
-- [[1]]
tails1 :: forall a. NonEmpty a -> NonEmpty (NonEmpty a) 
# if (MIN_VERSION_base(4,18,0)) || (MIN_VERSION_base_compat(0,13,1))
tails1 = onUnderlying @_ @(NE.NonEmpty (NE.NonEmpty a)) NE.tails1
#else
tails1 :: forall a. NonEmpty a -> NonEmpty (NonEmpty a)
tails1 = [NonEmpty a] -> NonEmpty (NonEmpty a)
forall a. [a] -> NonEmpty a
unsafeFromList ([NonEmpty a] -> NonEmpty (NonEmpty a))
-> (NonEmpty a -> [NonEmpty a])
-> NonEmpty a
-> NonEmpty (NonEmpty a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([a] -> NonEmpty a) -> [[a]] -> [NonEmpty a]
forall a b. (a -> b) -> [a] -> [b]
List.map [a] -> NonEmpty a
forall a. [a] -> NonEmpty a
unsafeFromList ([[a]] -> [NonEmpty a])
-> (NonEmpty a -> [[a]]) -> NonEmpty a -> [NonEmpty a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[a]] -> [[a]]
forall a. HasCallStack => [a] -> [a]
List.init ([[a]] -> [[a]]) -> (NonEmpty a -> [[a]]) -> NonEmpty a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [[a]]
forall a. [a] -> [[a]]
List.tails ([a] -> [[a]]) -> (NonEmpty a -> [a]) -> NonEmpty a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
toList
#endif

-- | A monomorphic version of <> for 'NonEmpty'.
--
-- >>> append [1] [2, 3]
-- [1, 2, 3]
append :: NonEmpty a -> NonEmpty a -> NonEmpty a 
append :: forall a. NonEmpty a -> NonEmpty a -> NonEmpty a
append (NonEmpty (a
x NE.:| [a]
xs)) (NonEmpty (a
y NE.:| [a]
ys))
  = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (a -> b) -> a -> b
$ a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
NE.:| ([a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ a
y a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
ys)

-- | Append a list at the end of a 'NonEmpty'.
--
-- >>> appendList [1, 2, 3] []
-- [1, 2, 3]
--
-- >>> appendList [1, 2, 3] [4, 5]
-- [1, 2, 3, 4, 5]
appendList :: NonEmpty a -> [a] -> NonEmpty a
appendList :: forall a. NonEmpty a -> [a] -> NonEmpty a
appendList (NonEmpty (a
x NE.:| [a]
xs)) [a]
ys
  = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (a -> b) -> a -> b
$ a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
NE.:| ([a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a]
ys)

-- | Prepend a list to the front of a 'NonEmpty'.
--
-- >>> prependList [] [1, 2, 3]
-- [1, 2, 3]
--
-- >>> prependList [negate 1, 0] [1, 2, 3]
-- [-1, 0, 1, 2, 3]
prependList :: [a] -> NonEmpty a -> NonEmpty a
prependList :: forall a. [a] -> NonEmpty a -> NonEmpty a
prependList [] NonEmpty a
xs = NonEmpty a
xs
prependList (a
x : [a]
xs) (NonEmpty (a
y NE.:| [a]
ys))
  = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonEmpty (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (a -> b) -> a -> b
$ a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
NE.:| ([a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ a
y a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
ys)


-- * Stream transformations

-- | Map a function over a NonEmpty stream.
map :: (a -> b) -> NonEmpty a -> NonEmpty b
map :: forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
map a -> b
f = (NonEmpty a -> NonEmpty b) -> NonEmpty a -> NonEmpty b
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying ((a -> b) -> NonEmpty a -> NonEmpty b
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
NE.map a -> b
f)

-- | Produces a 'NonEmpty' which alternates between elementes of
-- the input list, and the supplied element.
--
-- >>> intersperse 0 [1, 2, 3])
-- [1, 0, 2, 0, 3]
--
-- >>> intersperse 0 [1]
-- [1]
intersperse :: a -> NonEmpty a -> NonEmpty a 
intersperse :: forall a. a -> NonEmpty a -> NonEmpty a
intersperse a
el = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying (a -> NonEmpty a -> NonEmpty a
forall a. a -> NonEmpty a -> NonEmpty a
NE.intersperse a
el)

-- | Left-associative fold, lazy in the accumulator. See 'List.foldl'.
foldl1 :: (a -> a -> a) -> NonEmpty a -> a
foldl1 :: forall a. (a -> a -> a) -> NonEmpty a -> a
foldl1 a -> a -> a
f NonEmpty a
l = let (a
x, [a]
xs) = NonEmpty a -> (a, [a])
forall a. NonEmpty a -> (a, [a])
uncons NonEmpty a
l in
  (a -> a -> a) -> a -> [a] -> a
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl a -> a -> a
f a
x [a]
xs

-- | Left-associative fold, strict in the accumulator. See `List.foldl'`.
foldl1' :: (a -> a -> a) -> NonEmpty a -> a
foldl1' :: forall a. (a -> a -> a) -> NonEmpty a -> a
foldl1' a -> a -> a
f NonEmpty a
l = let (a
x, [a]
xs) = NonEmpty a -> (a, [a])
forall a. NonEmpty a -> (a, [a])
uncons NonEmpty a
l in
  (a -> a -> a) -> a -> [a] -> a
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' a -> a -> a
f a
x [a]
xs

-- | Left-associative fold, strict in the accumulator. See `List.foldl'`.
foldr1 :: (a -> a -> a) -> NonEmpty a -> a
foldr1 :: forall a. (a -> a -> a) -> NonEmpty a -> a
foldr1 a -> a -> a
f NonEmpty a
l = let ([a]
xs, a
x) = NonEmpty a -> ([a], a)
forall a. NonEmpty a -> ([a], a)
unsnoc NonEmpty a
l in
  (a -> a -> a) -> a -> [a] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
List.foldr a -> a -> a
f a
x [a]
xs

-- | scanl is similar to foldl, but returns a stream of successive
-- reduced values from the left:
--
-- >>> scanl (+) 1 [20, 300, 4000]
-- [1,21,321,4321]
scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b 
scanl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> f a -> NonEmpty b
scanl b -> a -> b
f b
initial f a
els = NonEmpty b -> NonEmpty b
forall a. NonEmpty a -> NonEmpty a
fromNonEmpty (NonEmpty b -> NonEmpty b) -> NonEmpty b -> NonEmpty b
forall a b. (a -> b) -> a -> b
$ (b -> a -> b) -> b -> [a] -> NonEmpty b
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> f a -> NonEmpty b
NE.scanl b -> a -> b
f b
initial (f a -> [a]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Foldable.toList f a
els)

-- | A strict version of 'scanl'.
scanl' :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b 
scanl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> f a -> NonEmpty b
scanl' b -> a -> b
f b
initial f a
els = [b] -> NonEmpty b
forall a. [a] -> NonEmpty a
unsafeFromList ([b] -> NonEmpty b) -> [b] -> NonEmpty b
forall a b. (a -> b) -> a -> b
$ (b -> a -> b) -> b -> [a] -> [b]
forall b a. (b -> a -> b) -> b -> [a] -> [b]
List.scanl' b -> a -> b
f b
initial (f a -> [a]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Foldable.toList f a
els)

-- | scanl1 is a variant of scanl that has no starting value argument:
--
-- @
-- scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, x1 `f` (x2 `f` x3), ...]
-- @
scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
scanl1 :: forall a. (a -> a -> a) -> NonEmpty a -> NonEmpty a
scanl1 a -> a -> a
f = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying ((a -> a -> a) -> NonEmpty a -> NonEmpty a
forall a. (a -> a -> a) -> NonEmpty a -> NonEmpty a
NE.scanl1 a -> a -> a
f)

-- | Right-to-left dual of scanl. Note that the order of parameters
-- on the accumulating function are reversed compared to scanl.
-- Also note that
--
-- @
-- head (scanr f z xs) == foldr f z xs
-- @
--
-- >>> scanr (+) 0 [1..4]
-- [10,9,7,4,0]
--
-- >>> scanr (+) 42 []
-- [42]
--
-- >>> scanr (-) 100 [1..4]
-- [98,-97,99,-96,100]
scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b 
scanr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> f a -> NonEmpty b
scanr a -> b -> b
f b
initial f a
els = NonEmpty b -> NonEmpty b
forall a. NonEmpty a -> NonEmpty a
fromNonEmpty (NonEmpty b -> NonEmpty b) -> NonEmpty b -> NonEmpty b
forall a b. (a -> b) -> a -> b
$ (a -> b -> b) -> b -> f a -> NonEmpty b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> f a -> NonEmpty b
NE.scanr a -> b -> b
f b
initial f a
els

-- | scanr1 is a variant of scanr that has no starting value argument.
--
-- >>> scanr1 (+) [1..4]
-- [10,9,7,4]
--
-- >>> scanr1 (+) []
-- []
--
-- >>> scanr1 (-) [1..4]
-- [-2,3,-1,4]
scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a 
scanr1 :: forall a. (a -> a -> a) -> NonEmpty a -> NonEmpty a
scanr1 a -> a -> a
f = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying ((a -> a -> a) -> NonEmpty a -> NonEmpty a
forall a. (a -> a -> a) -> NonEmpty a -> NonEmpty a
NE.scanr1 a -> a -> a
f)

-- | transpose for NonEmpty, behaves the same as 'List.transpose'.
-- The rows/columns need not be the same length, in which case
--
-- @
-- transpose . transpose /= id
-- @
transpose :: forall a. NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
transpose :: forall a. NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
transpose = forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying @_ @(NE.NonEmpty (NE.NonEmpty a)) NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
forall a. NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
NE.transpose

-- | Behaves the same as 'List.sortBy'
sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
sortBy :: forall a. (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
sortBy a -> a -> Ordering
f = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying ((a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
forall a. (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
NE.sortBy a -> a -> Ordering
f)

-- | Sort a list on a projection of its elements.
-- Projects once, then sorts, then un-projects.
-- This is useful when the projection function is expensive.
-- If it's not, you should probably use 'sortWith'.
sortOn :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a 
sortOn :: forall o a. Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
sortOn a -> o
f = ([a] -> [a]) -> NonEmpty a -> NonEmpty a
forall a b. ([a] -> [b]) -> NonEmpty a -> NonEmpty b
onList ((a -> o) -> [a] -> [a]
forall b a. Ord b => (a -> b) -> [a] -> [a]
List.sortOn a -> o
f)

-- | Sort a list on a projection of its elements.
-- Projects during comparison.
-- This is useful when the projection function is cheap.
-- If it's not, you should probably use 'sortOn'.
sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a 
sortWith :: forall o a. Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
sortWith a -> o
f = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying ((a -> o) -> NonEmpty a -> NonEmpty a
forall o a. Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
NE.sortWith a -> o
f)


-- * Building streams

-- | iterate f x produces the infinite sequence of repeated applications of f to x.
--
-- @
-- iterate f x = [x, f x, f (f x), ..]
-- @
iterate :: (a -> a) -> a -> NonEmpty a
iterate :: forall a. (a -> a) -> a -> NonEmpty a
iterate a -> a
f a
initial = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
fromNonEmpty (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (a -> b) -> a -> b
$ (a -> a) -> a -> NonEmpty a
forall a. (a -> a) -> a -> NonEmpty a
NE.iterate a -> a
f a
initial

-- | repeat x returns a constant stream, where all elements are equal to x.
repeat :: a -> NonEmpty a
repeat :: forall a. a -> NonEmpty a
repeat = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
fromNonEmpty (NonEmpty a -> NonEmpty a) -> (a -> NonEmpty a) -> a -> NonEmpty a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> NonEmpty a
forall a. a -> NonEmpty a
NE.repeat

-- | cycle xs returns the infinite repetition of xs:
--
-- @
-- cycle [1, 2, 3] == [1, 2, 3, 1, 2, 3, ...]
-- @
cycle :: NonEmpty a -> NonEmpty a
cycle :: forall a. NonEmpty a -> NonEmpty a
cycle = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (NonEmpty a -> NonEmpty b) -> NonEmpty a -> NonEmpty b
onNonEmpty NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NE.cycle

-- | insert x xs inserts x into the last position in xs where it is still
-- less than or equal to the next element. If the list is sorted beforehand,
-- the result will also be sorted.
insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a
insert :: forall (f :: * -> *) a.
(Foldable f, Ord a) =>
a -> f a -> NonEmpty a
insert a
el = [a] -> NonEmpty a
forall a. [a] -> NonEmpty a
unsafeFromList ([a] -> NonEmpty a) -> (f a -> [a]) -> f a -> NonEmpty a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a] -> [a]
forall a. Ord a => a -> [a] -> [a]
List.insert a
el ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Foldable.toList

-- | some1 x sequences x one or more times.
some1 :: Alternative f => f a -> f (NonEmpty a)
some1 :: forall (f :: * -> *) a. Alternative f => f a -> f (NonEmpty a)
some1 = (NonEmpty a -> NonEmpty a) -> f (NonEmpty a) -> f (NonEmpty a)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
fromNonEmpty (f (NonEmpty a) -> f (NonEmpty a))
-> (f a -> f (NonEmpty a)) -> f a -> f (NonEmpty a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> f (NonEmpty a)
forall (f :: * -> *) a. Alternative f => f a -> f (NonEmpty a)
NE.some1


-- * Extracting sublists

-- | take n xs returns the first n elements of xs.
take :: Int -> NonEmpty a -> [a]
take :: forall a. Int -> NonEmpty a -> [a]
take Int
n = Int -> NonEmpty a -> [a]
forall a. Int -> NonEmpty a -> [a]
NE.take Int
n (NonEmpty a -> [a])
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | drop n xs drops the first n elements from the front of the sequence xs.
drop :: Int -> NonEmpty a -> [a]
drop :: forall a. Int -> NonEmpty a -> [a]
drop Int
n = Int -> NonEmpty a -> [a]
forall a. Int -> NonEmpty a -> [a]
NE.drop Int
n (NonEmpty a -> [a])
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | splitAt n xs returns a pair consisting of the prefix of xs of length n and the remaining stream immediately following this prefix.
--
-- 'splitAt' n xs == ('take' n xs, 'drop' n xs)
splitAt :: Int -> NonEmpty a -> ([a], [a])
splitAt :: forall a. Int -> NonEmpty a -> ([a], [a])
splitAt Int
n = Int -> NonEmpty a -> ([a], [a])
forall a. Int -> NonEmpty a -> ([a], [a])
NE.splitAt Int
n (NonEmpty a -> ([a], [a]))
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Produces the longest prefix of the stream for which the predicate holds.
takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
takeWhile :: forall a. (a -> Bool) -> NonEmpty a -> [a]
takeWhile a -> Bool
f = (a -> Bool) -> NonEmpty a -> [a]
forall a. (a -> Bool) -> NonEmpty a -> [a]
NE.takeWhile a -> Bool
f (NonEmpty a -> [a])
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | dropWhile p xs produces the suffix remaining after takeWhile p xs.
dropWhile :: (a -> Bool) -> NonEmpty a -> [a]
dropWhile :: forall a. (a -> Bool) -> NonEmpty a -> [a]
dropWhile a -> Bool
f = (a -> Bool) -> NonEmpty a -> [a]
forall a. (a -> Bool) -> NonEmpty a -> [a]
NE.dropWhile a -> Bool
f (NonEmpty a -> [a])
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | span p xs returns the longest prefix of xs that satisfies p, together with the remainder of the stream.
--
-- 'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs)
span :: (a -> Bool) -> NonEmpty a -> ([a], [a])
span :: forall a. (a -> Bool) -> NonEmpty a -> ([a], [a])
span a -> Bool
f = (a -> Bool) -> NonEmpty a -> ([a], [a])
forall a. (a -> Bool) -> NonEmpty a -> ([a], [a])
NE.span a -> Bool
f (NonEmpty a -> ([a], [a]))
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | break p is equivalent to span (not . p).
break :: (a -> Bool) -> NonEmpty a -> ([a], [a])
break :: forall a. (a -> Bool) -> NonEmpty a -> ([a], [a])
break a -> Bool
f = (a -> Bool) -> NonEmpty a -> ([a], [a])
forall a. (a -> Bool) -> NonEmpty a -> ([a], [a])
NE.break a -> Bool
f (NonEmpty a -> ([a], [a]))
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Removes any elements of a nonempty stream that do not satisfy a predicate.
filter :: (a -> Bool) -> NonEmpty a -> [a]
filter :: forall a. (a -> Bool) -> NonEmpty a -> [a]
filter a -> Bool
f = (a -> Bool) -> NonEmpty a -> [a]
forall a. (a -> Bool) -> NonEmpty a -> [a]
NE.filter a -> Bool
f (NonEmpty a -> [a])
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Produces a pair of lists, the first of elements that satisfy the given
-- predicate, the second of elements that did not.
--
-- @
-- 'partition' p xs == ('filter' p xs, 'filter' (not . p) xs)
-- @
partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])
partition :: forall a. (a -> Bool) -> NonEmpty a -> ([a], [a])
partition a -> Bool
f = (a -> Bool) -> NonEmpty a -> ([a], [a])
forall a. (a -> Bool) -> NonEmpty a -> ([a], [a])
NE.partition a -> Bool
f (NonEmpty a -> ([a], [a]))
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty

-- | Takes a stream and returns a list of streams such that flattening
-- the resulting list is equal to the argument.
-- Moreover, each stream in the resulting list contains only equal elements.
--
-- >>> group "Mississippi"
-- ["M", "i", "ss", "i", "ss", "i", "pp", "i"]
group :: (Foldable f, Eq a) => f a -> [NonEmpty a]
group :: forall (f :: * -> *) a. (Foldable f, Eq a) => f a -> [NonEmpty a]
group = (a -> a -> Bool) -> f a -> [NonEmpty a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> Bool) -> f a -> [NonEmpty a]
groupBy a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)

-- | Similar to 'group', but sorts the input first so that each
-- equivalence class has, at most, one list in the output.
groupAll :: Ord a => [a] -> [NonEmpty a]
groupAll :: forall a. Ord a => [a] -> [NonEmpty a]
groupAll = (a -> a -> Ordering) -> [a] -> [NonEmpty a]
forall a. (a -> a -> Ordering) -> [a] -> [NonEmpty a]
groupAllBy a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare

-- | Similar to 'group', but uses the provided equality predicate instead of '=='.
groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]
groupBy :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> Bool) -> f a -> [NonEmpty a]
groupBy a -> a -> Bool
f = [NonEmpty a] -> [NonEmpty a]
forall a b. Coercible a b => a -> b
Exts.coerce ([NonEmpty a] -> [NonEmpty a])
-> (f a -> [NonEmpty a]) -> f a -> [NonEmpty a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Bool) -> f a -> [NonEmpty a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> Bool) -> f a -> [NonEmpty a]
NE.groupBy a -> a -> Bool
f

ordToEq :: (a -> b -> Ordering) -> a -> b -> Bool
ordToEq :: forall a b. (a -> b -> Ordering) -> a -> b -> Bool
ordToEq a -> b -> Ordering
f a
a b
b = a -> b -> Ordering
f a
a b
b Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ

-- | Similar to 'groupBy', but sorts the input first so that each
-- equivalence class has, at most, one list in the output.
groupAllBy :: (a -> a -> Ordering) -> [a] -> [NonEmpty a]
groupAllBy :: forall a. (a -> a -> Ordering) -> [a] -> [NonEmpty a]
groupAllBy a -> a -> Ordering
f = (a -> a -> Bool) -> [a] -> [NonEmpty a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> Bool) -> f a -> [NonEmpty a]
groupBy ((a -> a -> Ordering) -> a -> a -> Bool
forall a b. (a -> b -> Ordering) -> a -> b -> Bool
ordToEq a -> a -> Ordering
f) ([a] -> [NonEmpty a]) -> ([a] -> [a]) -> [a] -> [NonEmpty a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Ordering) -> [a] -> [a]
forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy a -> a -> Ordering
f

-- | Similar to 'group', but uses the provided projection when comparing for equality.
groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]
groupWith :: forall (f :: * -> *) b a.
(Foldable f, Eq b) =>
(a -> b) -> f a -> [NonEmpty a]
groupWith a -> b
f = [NonEmpty a] -> [NonEmpty a]
forall a b. Coercible a b => a -> b
Exts.coerce ([NonEmpty a] -> [NonEmpty a])
-> (f a -> [NonEmpty a]) -> f a -> [NonEmpty a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> f a -> [NonEmpty a]
forall (f :: * -> *) b a.
(Foldable f, Eq b) =>
(a -> b) -> f a -> [NonEmpty a]
NE.groupWith a -> b
f

-- | Similar to 'groupWith', but sorts the input first so that each
-- equivalence class has, at most, one list in the output.
groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]
groupAllWith :: forall b a. Ord b => (a -> b) -> [a] -> [NonEmpty a]
groupAllWith a -> b
f = [NonEmpty a] -> [NonEmpty a]
forall a b. Coercible a b => a -> b
Exts.coerce ([NonEmpty a] -> [NonEmpty a])
-> ([a] -> [NonEmpty a]) -> [a] -> [NonEmpty a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> [a] -> [NonEmpty a]
forall b a. Ord b => (a -> b) -> [a] -> [NonEmpty a]
NE.groupAllWith a -> b
f

-- | Similar to 'List.group', but uses the knowledge that its input is non-empty to
-- produce guaranteed non-empty output.
group1 :: forall a. Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
group1 :: forall a. Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
group1 = forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying @_ @(NE.NonEmpty (NE.NonEmpty a)) NonEmpty a -> NonEmpty (NonEmpty a)
forall a. Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
NE.group1

-- | Similar to 'group1', but sorts the input first so that each
-- equivalence class has, at most, one list in the output.
groupAll1 :: Ord a => NonEmpty a -> [NonEmpty a]
groupAll1 :: forall a. Ord a => NonEmpty a -> [NonEmpty a]
groupAll1 = NonEmpty a -> [NonEmpty a]
forall (f :: * -> *) a. (Foldable f, Eq a) => f a -> [NonEmpty a]
group (NonEmpty a -> [NonEmpty a])
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> [NonEmpty a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. Ord a => NonEmpty a -> NonEmpty a
sort

-- | Similar to 'group1', but uses the provided equality predicate instead of '=='.
groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupBy1 :: forall a. (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupBy1 a -> a -> Bool
f = (NonEmpty a -> NonEmpty (NonEmpty a))
-> NonEmpty a -> NonEmpty (NonEmpty a)
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying ((a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
forall a. (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
NE.groupBy1 a -> a -> Bool
f)

-- | Similar to 'group', but sorts the input first so that each
-- equivalence class has, at most, one list in the output.
groupAllBy1 :: (a -> a -> Ordering) -> [a] -> [NonEmpty a]
groupAllBy1 :: forall a. (a -> a -> Ordering) -> [a] -> [NonEmpty a]
groupAllBy1 a -> a -> Ordering
f = (a -> a -> Bool) -> [a] -> [NonEmpty a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> Bool) -> f a -> [NonEmpty a]
groupBy ((a -> a -> Ordering) -> a -> a -> Bool
forall a b. (a -> b -> Ordering) -> a -> b -> Bool
ordToEq a -> a -> Ordering
f) ([a] -> [NonEmpty a]) -> ([a] -> [a]) -> [a] -> [NonEmpty a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Ordering) -> [a] -> [a]
forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy a -> a -> Ordering
f

-- | Similar to 'group1', but uses the provided projection when comparing for equality.
groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupWith1 :: forall b a. Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupWith1 a -> b
f = (NonEmpty a -> NonEmpty (NonEmpty a))
-> NonEmpty a -> NonEmpty (NonEmpty a)
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying ((a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
forall b a. Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
NE.groupWith1 a -> b
f)

-- | Similar to 'groupWith1', but sorts the list first so that each
-- equivalence class has, at most, one list in the output.
groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupAllWith1 :: forall b a.
Ord b =>
(a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupAllWith1 a -> b
f = (NonEmpty a -> NonEmpty (NonEmpty a))
-> NonEmpty a -> NonEmpty (NonEmpty a)
forall a b c d.
(Coercible (NonEmpty c) a, Coercible b (NonEmpty d)) =>
(a -> b) -> NonEmpty c -> NonEmpty d
onUnderlying ((a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
forall b a.
Ord b =>
(a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
NE.groupAllWith1 a -> b
f)


-- * Sublist predicates

-- | Returns True if the first argument is a prefix of the second.
--
-- >>> isPrefixOf [1, 2, 3] [1, 2, 3, 4, 5]
-- True
-- >>> isPrefixOf "abc" "defghi"
-- False
-- >>> isPrefixOf "abc" ""
-- False
isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool
isPrefixOf :: forall a. Eq a => [a] -> NonEmpty a -> Bool
isPrefixOf [a]
els = [a] -> NonEmpty a -> Bool
forall a. Eq a => [a] -> NonEmpty a -> Bool
NE.isPrefixOf [a]
els (NonEmpty a -> Bool)
-> (NonEmpty a -> NonEmpty a) -> NonEmpty a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
toNonEmpty


-- * "Set" operations

-- | Removes duplicate elements from a list. In particular, it keeps only
-- the first occurrence of each element. (The name nub means 'essence'.)
-- It is a special case of nubBy, which allows the programmer to supply
-- their own inequality test.
nub :: Eq a => NonEmpty a -> NonEmpty a 
nub :: forall a. Eq a => NonEmpty a -> NonEmpty a
nub = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (NonEmpty a -> NonEmpty b) -> NonEmpty a -> NonEmpty b
onNonEmpty NonEmpty a -> NonEmpty a
forall a. Eq a => NonEmpty a -> NonEmpty a
NE.nub

-- | Behaves just like nub, except it uses a user-supplied equality
-- predicate instead of the overloaded '==' function.
nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a 
nubBy :: forall a. (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
nubBy a -> a -> Bool
f = (NonEmpty a -> NonEmpty a) -> NonEmpty a -> NonEmpty a
forall a b. (NonEmpty a -> NonEmpty b) -> NonEmpty a -> NonEmpty b
onNonEmpty ((a -> a -> Bool) -> NonEmpty a -> NonEmpty a
forall a. (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
NE.nubBy a -> a -> Bool
f)


-- * Indexing streams

infixl 9 !?

-- | xs !! n returns the element of the stream xs at index n, if present.
-- Note that the head of the stream has index 0.
(!?) :: NonEmpty a -> Int -> Maybe a
!? :: forall a. NonEmpty a -> Int -> Maybe a
(!?) NonEmpty a
l Int
n
  | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = Maybe a
forall a. Maybe a
Nothing
  | Bool
otherwise = [a] -> Maybe a
forall a. [a] -> Maybe a
listToMaybe ([a] -> Maybe a) -> [a] -> Maybe a
forall a b. (a -> b) -> a -> b
$ Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
List.drop Int
n ([a] -> [a]) -> [a] -> [a]
forall a b. (a -> b) -> a -> b
$ NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
toList NonEmpty a
l

-- * Zipping streams

-- | \(\mathcal{O}(\min(m,n))\).
-- Takes two streams and produces a stream of corresponding pairs.
--
-- >>> zip [1, 2] ['a', 'b']
-- [(1, 'a'),(2, 'b')]
zip :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b) 
zip :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
zip NonEmpty a
l1 NonEmpty b
l2 = forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
Exts.coerce @(NE.NonEmpty (a, b)) (NonEmpty (a, b) -> NonEmpty (a, b))
-> NonEmpty (a, b) -> NonEmpty (a, b)
forall a b. (a -> b) -> a -> b
$ NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
NE.zip (NonEmpty a -> NonEmpty a
forall a b. Coercible a b => a -> b
Exts.coerce NonEmpty a
l1) (NonEmpty b -> NonEmpty b
forall a b. Coercible a b => a -> b
Exts.coerce NonEmpty b
l2)

-- | \(\mathcal{O}(\min(m,n))\).
-- Generalises zip by zipping with the provided function, instead of
-- a tupling function.
zipWith :: forall a b c. (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c 
zipWith :: forall a b c.
(a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
zipWith a -> b -> c
f NonEmpty a
l1 NonEmpty b
l2 = forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
Exts.coerce @(NE.NonEmpty c) (NonEmpty c -> NonEmpty c) -> NonEmpty c -> NonEmpty c
forall a b. (a -> b) -> a -> b
$ (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
forall a b c.
(a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
NE.zipWith a -> b -> c
f (NonEmpty a -> NonEmpty a
forall a b. Coercible a b => a -> b
Exts.coerce NonEmpty a
l1) (NonEmpty b -> NonEmpty b
forall a b. Coercible a b => a -> b
Exts.coerce NonEmpty b
l2)