{-# LANGUAGE CPP                        #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# 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(..)
  , Int
  , Maybe(..)
  , Monad(..)
  , Ord(..)
  , Ordering(..)
  , Show(..)
  , ($)
  , (.)
  , (++)
  , error
  , fail
  , otherwise
  )

import Data.Bool                       (not, (&&))
import Control.Applicative             (Alternative)
import Control.Monad.Fix               (MonadFix)
import Control.Monad.Zip               (MonadZip)
import Data.Bifunctor                  (first)
import Data.Data                       (Data)
import Data.Foldable                   (Foldable)
#if MIN_VERSION_base(4,18,0)
import Data.Foldable1                  (Foldable1)
#endif
import Data.Functor                    (Functor(..))
import Data.Functor.Classes            (Eq1(..), Ord1(..), Read1(..), Show1(..))
import Data.Function                   ((&))
import Data.Maybe                      (listToMaybe)
import Data.Tuple                      (swap, fst)
import Data.Semigroup                  (Semigroup(..))
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)
  -- `stock` deriving strategy is used where possible,
  -- `newtype` is fallen back on
  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
    , 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
    , (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
    , (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
    , 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
    , 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
#if MIN_VERSION_base(4,10,0)
    , (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
#endif
    , 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
    , 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
    )

#if !MIN_VERSION_base(4,10,0)
instance Eq1 NonEmpty where
  liftEq f (x :| xs) (y :| ys) = f x y && liftEq f xs ys

instance Ord1 NonEmpty where
  liftCompare f (x :| xs) (y :| ys) = case f x y of
    LT -> LT
    GT -> GT
    EQ -> liftCompare f xs ys

instance Read1 NonEmpty where
  liftReadsPrec a b c s = liftReadsPrec a b c s
    & List.filter (not . List.null . fst)
    & fmap (first unsafeFromList)

instance Show1 NonEmpty where
  liftShowsPrec a b c = liftShowsPrec a b c . toList
#endif

{-# 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 [] = String -> NonEmpty a
forall a. HasCallStack => String -> a
error String
"Tried to create a (Neo)NonEmpty list from an empty list"
unsafeFromList (a
x : [a]
xs) = a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
xs

-- 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)