{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE LinearTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -Wno-name-shadowing #-}
{-# OPTIONS_GHC -Wno-orphans #-}

-- |
-- Linear versions of 'NonEmpty' functions.
--
-- This module only contains minimal amount of documentation; consult the
-- original "Data.List.NonEmpty" module for more detailed information.
module Data.List.NonEmpty.Linear
  ( -- * Non-empty stream transformations
    NonEmpty (..),
    map,
    intersperse,
    scanl,
    scanr,
    scanl1,
    scanr1,
    transpose,
    NonLinear.sortBy,
    NonLinear.sortWith,

    -- * Basic functions
    length,
    NonLinear.head,
    NonLinear.tail,
    NonLinear.last,
    NonLinear.init,
    singleton,
    (<|),
    cons,
    uncons,
    unfoldr,
    NonLinear.sort,
    reverse,
    append,
    appendList,
    prependList,

    -- * Extracting sublists
    take,
    drop,
    splitAt,
    takeWhile,
    dropWhile,
    span,
    break,
    filter,
    partition,

    -- * Zipping and unzipping streams
    zip,
    zipWith,
    zip',
    zipWith',
    unzip,
    unzip3,

    -- * Converting to and from a list
    fromList,
    toList,
    nonEmpty,
    xor,
  )
where

import qualified Data.List.Linear as List
import Data.List.NonEmpty (NonEmpty (..))
import qualified Data.List.NonEmpty as NonLinear
import Data.Vector.Internal.Check (HasCallStack)
import Prelude.Linear hiding (drop, dropWhile, filter, intersperse, length, map, partition, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, take, takeWhile, transpose, uncons, unfoldr, unzip, unzip3, zip, zip', zipWith, zipWith')
import qualified Unsafe.Linear as Unsafe
import qualified Prelude as Prelude

map :: (a %1 -> b) -> NonEmpty a %1 -> NonEmpty b
map :: forall a b. (a %1 -> b) -> NonEmpty a %1 -> NonEmpty b
map a %1 -> b
f (a
x :| [a]
xs) = a %1 -> b
f a
x b -> [b] -> NonEmpty b
forall a. a -> [a] -> NonEmpty a
:| (a %1 -> b) -> [a] %1 -> [b]
forall a b. (a %1 -> b) -> [a] %1 -> [b]
List.map a %1 -> b
f [a]
xs

intersperse :: a -> NonEmpty a %1 -> NonEmpty a
intersperse :: forall a. a -> NonEmpty a %1 -> NonEmpty a
intersperse a
a = (NonEmpty a -> NonEmpty a) %1 -> NonEmpty a %1 -> NonEmpty a
forall a b (p :: Multiplicity) (x :: Multiplicity).
(a %p -> b) %1 -> a %x -> b
Unsafe.toLinear (a -> NonEmpty a -> NonEmpty a
forall a. a -> NonEmpty a -> NonEmpty a
NonLinear.intersperse a
a)

reverse :: NonEmpty a %1 -> NonEmpty a
reverse :: forall a. NonEmpty a %1 -> NonEmpty a
reverse = (NonEmpty a -> NonEmpty a) %1 -> NonEmpty a %1 -> NonEmpty a
forall a b (p :: Multiplicity) (x :: Multiplicity).
(a %p -> b) %1 -> a %x -> b
Unsafe.toLinear NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NonLinear.reverse

scanl :: (Dupable b) => (b %1 -> a %1 -> b) -> b %1 -> NonEmpty a %1 -> NonEmpty b
scanl :: forall b a.
Dupable b =>
(b %1 -> a %1 -> b) -> b %1 -> NonEmpty a %1 -> NonEmpty b
scanl b %1 -> a %1 -> b
f b
z = [b] %1 -> NonEmpty b
forall a. HasCallStack => [a] %1 -> NonEmpty a
fromList ([b] %1 -> NonEmpty b)
-> (NonEmpty a %1 -> [b]) %1 -> NonEmpty a %1 -> NonEmpty b
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. (b %1 -> a %1 -> b) -> b %1 -> [a] %1 -> [b]
forall b a.
Dupable b =>
(b %1 -> a %1 -> b) -> b %1 -> [a] %1 -> [b]
List.scanl b %1 -> a %1 -> b
f b
z ([a] %1 -> [b])
%1 -> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> [b]
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

scanr :: (Dupable b) => (a %1 -> b %1 -> b) -> b %1 -> NonEmpty a %1 -> NonEmpty b
scanr :: forall b a.
Dupable b =>
(a %1 -> b %1 -> b) -> b %1 -> NonEmpty a %1 -> NonEmpty b
scanr a %1 -> b %1 -> b
f b
z = [b] %1 -> NonEmpty b
forall a. HasCallStack => [a] %1 -> NonEmpty a
fromList ([b] %1 -> NonEmpty b)
-> (NonEmpty a %1 -> [b]) %1 -> NonEmpty a %1 -> NonEmpty b
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. (a %1 -> b %1 -> b) -> b %1 -> [a] %1 -> [b]
forall b a.
Dupable b =>
(a %1 -> b %1 -> b) -> b %1 -> [a] %1 -> [b]
List.scanr a %1 -> b %1 -> b
f b
z ([a] %1 -> [b])
%1 -> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> [b]
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

scanl1 :: (Dupable a) => (a %1 -> a %1 -> a) -> NonEmpty a %1 -> NonEmpty a
scanl1 :: forall a.
Dupable a =>
(a %1 -> a %1 -> a) -> NonEmpty a %1 -> NonEmpty a
scanl1 a %1 -> a %1 -> a
f (a
x :| [a]
xs) = [a] %1 -> NonEmpty a
forall a. HasCallStack => [a] %1 -> NonEmpty a
fromList ([a] %1 -> NonEmpty a) -> [a] %1 -> NonEmpty a
forall a b (p :: Multiplicity) (q :: Multiplicity).
(a %p -> b) %q -> a %p -> b
$ (a %1 -> a %1 -> a) -> a %1 -> [a] %1 -> [a]
forall b a.
Dupable b =>
(b %1 -> a %1 -> b) -> b %1 -> [a] %1 -> [b]
List.scanl a %1 -> a %1 -> a
f a
x [a]
xs

scanr1 :: (Dupable a) => (a %1 -> a %1 -> a) -> NonEmpty a %1 -> NonEmpty a
scanr1 :: forall a.
Dupable a =>
(a %1 -> a %1 -> a) -> NonEmpty a %1 -> NonEmpty a
scanr1 a %1 -> a %1 -> a
f (a
x :| [a]
xs) = [a] %1 -> NonEmpty a
forall a. HasCallStack => [a] %1 -> NonEmpty a
fromList ([a] %1 -> NonEmpty a) -> [a] %1 -> NonEmpty a
forall a b (p :: Multiplicity) (q :: Multiplicity).
(a %p -> b) %q -> a %p -> b
$ (a %1 -> a %1 -> a) -> [a] %1 -> [a]
forall a. Dupable a => (a %1 -> a %1 -> a) -> [a] %1 -> [a]
List.scanr1 a %1 -> a %1 -> a
f (a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs)

transpose :: NonEmpty (NonEmpty a) %1 -> NonEmpty (NonEmpty a)
transpose :: forall a. NonEmpty (NonEmpty a) %1 -> NonEmpty (NonEmpty a)
transpose = (NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a))
%1 -> NonEmpty (NonEmpty a) %1 -> NonEmpty (NonEmpty a)
forall a b (p :: Multiplicity) (x :: Multiplicity).
(a %p -> b) %1 -> a %x -> b
Unsafe.toLinear NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
forall a. NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
NonLinear.transpose

singleton :: a %1 -> NonEmpty a
singleton :: forall a. a %1 -> NonEmpty a
singleton = (a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [])

infixr 5 <|

(<|) :: a %1 -> NonEmpty a %1 -> NonEmpty a
a
a <| :: forall a. a %1 -> NonEmpty a %1 -> NonEmpty a
<| NonEmpty a
bs = a
a a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList NonEmpty a
bs

cons :: a %1 -> NonEmpty a %1 -> NonEmpty a
cons :: forall a. a %1 -> NonEmpty a %1 -> NonEmpty a
cons = a %1 -> NonEmpty a %1 -> NonEmpty a
forall a. a %1 -> NonEmpty a %1 -> NonEmpty a
(<|)

uncons :: NonEmpty a %1 -> (a, Maybe (NonEmpty a))
uncons :: forall a. NonEmpty a %1 -> (a, Maybe (NonEmpty a))
uncons (a
x :| [a]
xs) = (a
x, [a] %1 -> Maybe (NonEmpty a)
forall a. [a] %1 -> Maybe (NonEmpty a)
nonEmpty [a]
xs)

unfoldr :: (a %1 -> (b, Maybe a)) -> a %1 -> NonEmpty b
unfoldr :: forall a b. (a %1 -> (b, Maybe a)) -> a %1 -> NonEmpty b
unfoldr a %1 -> (b, Maybe a)
f a
a = case a %1 -> (b, Maybe a)
f a
a of
  (b
b, Maybe a
mc) -> b
b b -> [b] -> NonEmpty b
forall a. a -> [a] -> NonEmpty a
:| [b] -> (a %1 -> [b]) -> Maybe a %1 -> [b]
forall b a. b -> (a %1 -> b) -> Maybe a %1 -> b
maybe [] a %1 -> [b]
go Maybe a
mc
  where
    go :: a %1 -> [b]
go a
c = case a %1 -> (b, Maybe a)
f a
c of
      (b
d, Maybe a
me) -> b
d b -> [b] -> [b]
forall a. a -> [a] -> [a]
: [b] -> (a %1 -> [b]) -> Maybe a %1 -> [b]
forall b a. b -> (a %1 -> b) -> Maybe a %1 -> b
maybe [] a %1 -> [b]
go Maybe a
me

append :: NonEmpty a %1 -> NonEmpty a %1 -> NonEmpty a
append :: forall a. NonEmpty a %1 -> NonEmpty a %1 -> NonEmpty a
append = NonEmpty a %1 -> NonEmpty a %1 -> NonEmpty a
forall a. Semigroup a => a %1 -> a %1 -> a
(<>)

appendList :: NonEmpty a %1 -> [a] %1 -> NonEmpty a
appendList :: forall a. NonEmpty a %1 -> [a] %1 -> NonEmpty a
appendList (a
x :| [a]
xs) [a]
ys = a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| ([a]
xs [a] %1 -> [a] %1 -> [a]
forall a. Semigroup a => a %1 -> a %1 -> a
<> [a]
ys)

prependList :: [a] %1 -> NonEmpty a %1 -> NonEmpty a
prependList :: forall a. [a] %1 -> NonEmpty a %1 -> NonEmpty a
prependList [a]
ls NonEmpty a
ne = case [a]
ls of
  [] -> NonEmpty a
ne
  (a
y : [a]
ys) -> a
y a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| ([a]
ys [a] %1 -> [a] %1 -> [a]
forall a. Semigroup a => a %1 -> a %1 -> a
<> NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList NonEmpty a
ne)

-- | __NOTE__: This does not short-circuit and always traverses the
-- entire list to consume the rest of the elements.
take :: (Consumable a) => Int -> NonEmpty a %1 -> [a]
take :: forall a. Consumable a => Int -> NonEmpty a %1 -> [a]
take Int
n = Int -> [a] %1 -> [a]
forall a. Consumable a => Int -> [a] %1 -> [a]
List.take Int
n ([a] %1 -> [a]) -> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> [a]
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

drop :: (Consumable a) => Int -> NonEmpty a %1 -> [a]
drop :: forall a. Consumable a => Int -> NonEmpty a %1 -> [a]
drop Int
n = Int -> [a] %1 -> [a]
forall a. Consumable a => Int -> [a] %1 -> [a]
List.drop Int
n ([a] %1 -> [a]) -> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> [a]
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

splitAt :: (Consumable a) => Int -> NonEmpty a %1 -> ([a], [a])
splitAt :: forall a. Consumable a => Int -> NonEmpty a %1 -> ([a], [a])
splitAt Int
n = Int -> [a] %1 -> ([a], [a])
forall a. Int -> [a] %1 -> ([a], [a])
List.splitAt Int
n ([a] %1 -> ([a], [a]))
-> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> ([a], [a])
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

-- | __NOTE__: This does not short-circuit and always traverses the
-- entire list to consume the rest of the elements.
takeWhile :: (Dupable a) => (a %1 -> Bool) -> NonEmpty a %1 -> [a]
takeWhile :: forall a. Dupable a => (a %1 -> Bool) -> NonEmpty a %1 -> [a]
takeWhile a %1 -> Bool
p = (a %1 -> Bool) -> [a] %1 -> [a]
forall a. Dupable a => (a %1 -> Bool) -> [a] %1 -> [a]
List.takeWhile a %1 -> Bool
p ([a] %1 -> [a]) -> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> [a]
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

dropWhile :: (Dupable a) => (a %1 -> Bool) -> NonEmpty a %1 -> [a]
dropWhile :: forall a. Dupable a => (a %1 -> Bool) -> NonEmpty a %1 -> [a]
dropWhile a %1 -> Bool
p = (a %1 -> Bool) -> [a] %1 -> [a]
forall a. Dupable a => (a %1 -> Bool) -> [a] %1 -> [a]
List.dropWhile a %1 -> Bool
p ([a] %1 -> [a]) -> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> [a]
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

span :: (Dupable a) => (a %1 -> Bool) -> NonEmpty a %1 -> ([a], [a])
span :: forall a.
Dupable a =>
(a %1 -> Bool) -> NonEmpty a %1 -> ([a], [a])
span a %1 -> Bool
p = (a %1 -> Bool) -> [a] %1 -> ([a], [a])
forall a. Dupable a => (a %1 -> Bool) -> [a] %1 -> ([a], [a])
List.span a %1 -> Bool
p ([a] %1 -> ([a], [a]))
-> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> ([a], [a])
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

break :: (Dupable a) => (a %1 -> Bool) -> NonEmpty a %1 -> ([a], [a])
break :: forall a.
Dupable a =>
(a %1 -> Bool) -> NonEmpty a %1 -> ([a], [a])
break a %1 -> Bool
p = (a %1 -> Bool) -> NonEmpty a %1 -> ([a], [a])
forall a.
Dupable a =>
(a %1 -> Bool) -> NonEmpty a %1 -> ([a], [a])
span (Bool %1 -> Bool
not (Bool %1 -> Bool) -> (a %1 -> Bool) -> a %1 -> Bool
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. a %1 -> Bool
p)

filter :: (Dupable a) => (a %1 -> Bool) -> NonEmpty a %1 -> [a]
filter :: forall a. Dupable a => (a %1 -> Bool) -> NonEmpty a %1 -> [a]
filter a %1 -> Bool
p = (a %1 -> Bool) -> [a] %1 -> [a]
forall a. Dupable a => (a %1 -> Bool) -> [a] %1 -> [a]
List.filter a %1 -> Bool
p ([a] %1 -> [a]) -> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> [a]
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

partition :: (Dupable a) => (a %1 -> Bool) -> NonEmpty a %1 -> ([a], [a])
partition :: forall a.
Dupable a =>
(a %1 -> Bool) -> NonEmpty a %1 -> ([a], [a])
partition a %1 -> Bool
p = (a %1 -> Bool) -> [a] %1 -> ([a], [a])
forall a. Dupable a => (a %1 -> Bool) -> [a] %1 -> ([a], [a])
List.partition a %1 -> Bool
p ([a] %1 -> ([a], [a]))
-> (NonEmpty a %1 -> [a]) -> NonEmpty a %1 -> ([a], [a])
forall b c a (q :: Multiplicity) (m :: Multiplicity)
       (n :: Multiplicity).
(b %1 -> c) %q -> (a %1 -> b) %m -> a %n -> c
. NonEmpty a %1 -> [a]
forall a. NonEmpty a %1 -> [a]
toList

-- | Return the length of the given list alongside with the list itself.
length :: NonEmpty a %1 -> (Ur Int, NonEmpty a)
length :: forall a. NonEmpty a %1 -> (Ur Int, NonEmpty a)
length = (NonEmpty a -> (Ur Int, NonEmpty a))
%1 -> NonEmpty a %1 -> (Ur Int, NonEmpty a)
forall a b (p :: Multiplicity) (x :: Multiplicity).
(a %p -> b) %1 -> a %x -> b
Unsafe.toLinear ((NonEmpty a -> (Ur Int, NonEmpty a))
 %1 -> NonEmpty a %1 -> (Ur Int, NonEmpty a))
-> (NonEmpty a -> (Ur Int, NonEmpty a))
%1 -> NonEmpty a
%1 -> (Ur Int, NonEmpty a)
forall a b (p :: Multiplicity) (q :: Multiplicity).
(a %p -> b) %q -> a %p -> b
$ \NonEmpty a
xs ->
  (Int -> Ur Int
forall a. a -> Ur a
Ur (NonEmpty a -> Int
forall a. NonEmpty a -> Int
NonLinear.length NonEmpty a
xs), NonEmpty a
xs)

fromList :: (HasCallStack) => [a] %1 -> (NonEmpty a)
fromList :: forall a. HasCallStack => [a] %1 -> NonEmpty a
fromList (a
x : [a]
xs) = a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
xs
fromList [] = [Char] -> NonEmpty a
forall a. HasCallStack => [Char] -> a
Prelude.error [Char]
"NonEmpty.Linear.fromList: empty list"

toList :: NonEmpty a %1 -> [a]
toList :: forall a. NonEmpty a %1 -> [a]
toList (a
x :| [a]
xs) = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs

nonEmpty :: [a] %1 -> Maybe (NonEmpty a)
nonEmpty :: forall a. [a] %1 -> Maybe (NonEmpty a)
nonEmpty (a
x : [a]
xs) = NonEmpty a -> Maybe (NonEmpty a)
forall a. a -> Maybe a
Just (a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
xs)
nonEmpty [] = Maybe (NonEmpty a)
forall a. Maybe a
Nothing

xor :: NonEmpty Bool %1 -> Bool
xor :: NonEmpty Bool %1 -> Bool
xor = (NonEmpty Bool -> Bool) %1 -> NonEmpty Bool %1 -> Bool
forall a b (p :: Multiplicity) (x :: Multiplicity).
(a %p -> b) %1 -> a %x -> b
Unsafe.toLinear NonEmpty Bool -> Bool
NonLinear.xor

zip :: (Consumable a, Consumable b) => NonEmpty a %1 -> NonEmpty b %1 -> NonEmpty (a, b)
zip :: forall a b.
(Consumable a, Consumable b) =>
NonEmpty a %1 -> NonEmpty b %1 -> NonEmpty (a, b)
zip = (a %1 -> b %1 -> (a, b))
-> NonEmpty a %1 -> NonEmpty b %1 -> NonEmpty (a, b)
forall a b c.
(Consumable a, Consumable b) =>
(a %1 -> b %1 -> c) -> NonEmpty a %1 -> NonEmpty b %1 -> NonEmpty c
zipWith (,)

zipWith :: (Consumable a, Consumable b) => (a %1 -> b %1 -> c) -> NonEmpty a %1 -> NonEmpty b %1 -> NonEmpty c
zipWith :: forall a b c.
(Consumable a, Consumable b) =>
(a %1 -> b %1 -> c) -> NonEmpty a %1 -> NonEmpty b %1 -> NonEmpty c
zipWith a %1 -> b %1 -> c
f (a
a :| [a]
as) (b
b :| [b]
bs) = a %1 -> b %1 -> c
f a
a b
b c -> [c] -> NonEmpty c
forall a. a -> [a] -> NonEmpty a
:| (a %1 -> b %1 -> c) -> [a] %1 -> [b] %1 -> [c]
forall a b c.
(Consumable a, Consumable b) =>
(a %1 -> b %1 -> c) -> [a] %1 -> [b] %1 -> [c]
List.zipWith a %1 -> b %1 -> c
f [a]
as [b]
bs

-- | Same as 'zipWith', but returns the leftovers instead of consuming them.
-- Because the leftovers are returned at toplevel, @zipWith'@ is pretty strict:
-- forcing the second cons cell of the returned list forces all the recursive
-- calls.
zipWith' :: (a %1 -> b %1 -> c) -> NonEmpty a %1 -> NonEmpty b %1 -> (NonEmpty c, Maybe (Either (NonEmpty a) (NonEmpty b)))
zipWith' :: forall a b c.
(a %1 -> b %1 -> c)
-> NonEmpty a
%1 -> NonEmpty b
%1 -> (NonEmpty c, Maybe (Either (NonEmpty a) (NonEmpty b)))
zipWith' a %1 -> b %1 -> c
f (a
a :| [a]
as) (b
b :| [b]
bs) =
  case (a %1 -> b %1 -> c)
-> [a]
%1 -> [b]
%1 -> ([c], Maybe (Either (NonEmpty a) (NonEmpty b)))
forall a b c.
(a %1 -> b %1 -> c)
-> [a]
%1 -> [b]
%1 -> ([c], Maybe (Either (NonEmpty a) (NonEmpty b)))
List.zipWith' a %1 -> b %1 -> c
f [a]
as [b]
bs of
    ([c]
cs, Maybe (Either (NonEmpty a) (NonEmpty b))
may) -> (a %1 -> b %1 -> c
f a
a b
b c -> [c] -> NonEmpty c
forall a. a -> [a] -> NonEmpty a
:| [c]
cs, Maybe (Either (NonEmpty a) (NonEmpty b))
may)

-- | Same as 'zip', but returns the leftovers instead of consuming them.
zip' :: NonEmpty a %1 -> NonEmpty b %1 -> (NonEmpty (a, b), Maybe (Either (NonEmpty a) (NonEmpty b)))
zip' :: forall a b.
NonEmpty a
%1 -> NonEmpty b
%1 -> (NonEmpty (a, b), Maybe (Either (NonEmpty a) (NonEmpty b)))
zip' = (a %1 -> b %1 -> (a, b))
-> NonEmpty a
%1 -> NonEmpty b
%1 -> (NonEmpty (a, b), Maybe (Either (NonEmpty a) (NonEmpty b)))
forall a b c.
(a %1 -> b %1 -> c)
-> NonEmpty a
%1 -> NonEmpty b
%1 -> (NonEmpty c, Maybe (Either (NonEmpty a) (NonEmpty b)))
zipWith' (,)

unzip :: NonEmpty (a, b) %1 -> (NonEmpty a, NonEmpty b)
unzip :: forall a b. NonEmpty (a, b) %1 -> (NonEmpty a, NonEmpty b)
unzip ((a
a, b
b) :| [(a, b)]
asbs) =
  [(a, b)] %1 -> ([a], [b])
forall a b. [(a, b)] %1 -> ([a], [b])
List.unzip [(a, b)]
asbs ([a], [b])
%1 -> (([a], [b]) %1 -> (NonEmpty a, NonEmpty b))
%1 -> (NonEmpty a, NonEmpty b)
forall a b (p :: Multiplicity) (q :: Multiplicity).
a %p -> (a %p -> b) %q -> b
& \([a]
as, [b]
bs) ->
    (a
a a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
as, b
b b -> [b] -> NonEmpty b
forall a. a -> [a] -> NonEmpty a
:| [b]
bs)

unzip3 :: NonEmpty (a, b, c) %1 -> (NonEmpty a, NonEmpty b, NonEmpty c)
unzip3 :: forall a b c.
NonEmpty (a, b, c) %1 -> (NonEmpty a, NonEmpty b, NonEmpty c)
unzip3 ((a
a, b
b, c
c) :| [(a, b, c)]
abs) =
  [(a, b, c)] %1 -> ([a], [b], [c])
forall a b c. [(a, b, c)] %1 -> ([a], [b], [c])
List.unzip3 [(a, b, c)]
abs ([a], [b], [c])
%1 -> (([a], [b], [c]) %1 -> (NonEmpty a, NonEmpty b, NonEmpty c))
%1 -> (NonEmpty a, NonEmpty b, NonEmpty c)
forall a b (p :: Multiplicity) (q :: Multiplicity).
a %p -> (a %p -> b) %q -> b
& \([a]
as, [b]
bs, [c]
cs) ->
    (a
a a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
as, b
b b -> [b] -> NonEmpty b
forall a. a -> [a] -> NonEmpty a
:| [b]
bs, c
c c -> [c] -> NonEmpty c
forall a. a -> [a] -> NonEmpty a
:| [c]
cs)