Bodigrim pushed to branch wip/zip-them-all at Glasgow Haskell Compiler / GHC

Commits:

6 changed files:

Changes:

  • compiler/GHC/Data/List/NonEmpty.hs
    1 
    +{-# OPTIONS_GHC -Wno-dodgy-imports #-}
    1 2 
     module GHC.Data.List.NonEmpty (module Data.List.NonEmpty, module GHC.Data.List.NonEmpty, toList) where
    2 3
    3 4 
     import Prelude (Bool, (.))
    4 5 
     import Control.Applicative
    5 6 
     import qualified Control.Monad as List (zipWithM)
    6 7 
     import Data.Foldable (Foldable (toList))
    7 
    -import Data.List.NonEmpty hiding (toList, unzip)
    8 
    +import Data.List.NonEmpty hiding (toList, unzip, unzip3)
    8 9 
     import qualified Data.List as List
    9 10 
     import qualified GHC.Data.List as List
    10 11

  • libraries/base/changelog.md
    ... ... @@ -3,6 +3,7 @@
    3 3 
     ## 4.24.0.0 *TBA*
    4 4 
       * Add `Bounded` instances for `Double`, `Float`, `CDouble` and `CFloat`. ([CLC proposal #402](https://github.com/haskell/core-libraries-committee/issues/402))
    5 5 
       * Ensure that `Data.List.elem` and `notElem` can be specialized even when no list fusion happens. ([CLC proposal #412)(https://github.com/haskell/core-libraries-committee/issues/412))
    6 
    +  * Add `Data.List.NonEmpty.{zip{3..7},zipWith{3..7},unzip{3..7}} ([CLC proposal #409)(https://github.com/haskell/core-libraries-committee/issues/409))
    6 7
    7 8 
     ## 4.23.0.0 *TBA*
    8 9 
       * Add `System.IO.hGetNewlineMode`. ([CLC proposal #370](https://github.com/haskell/core-libraries-committee/issues/370))

  • libraries/base/src/Data/List/NonEmpty.hs
    ... ... @@ -99,10 +99,29 @@ module Data.List.NonEmpty (
    99 99 
        , nubOrdBy    -- :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
    100 100 
        -- * Indexing streams
    101 101 
        , (!!)        -- :: NonEmpty a -> Int -> a
    102 
    +
    102 103 
        -- * Zipping and unzipping streams
    103 
    -   , zip         -- :: NonEmpty a -> NonEmpty b -> NonEmpty (a,b)
    104 
    -   , zipWith     -- :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
    105 
    -   , unzip       -- :: Functor f => f (a,b) -> (f a, f b)
    104 
    +   , zip
    105 
    +   , zip3
    106 
    +   , zip4
    107 
    +   , zip5
    108 
    +   , zip6
    109 
    +   , zip7
    110 
    +
    111 
    +   , zipWith
    112 
    +   , zipWith3
    113 
    +   , zipWith4
    114 
    +   , zipWith5
    115 
    +   , zipWith6
    116 
    +   , zipWith7
    117 
    +
    118 
    +   , unzip
    119 
    +   , unzip3
    120 
    +   , unzip4
    121 
    +   , unzip5
    122 
    +   , unzip6
    123 
    +   , unzip7
    124 
    +
    106 125 
        -- * Converting to and from a list
    107 126 
        , fromList    -- :: [a] -> NonEmpty a
    108 127 
        , toList      -- :: NonEmpty a -> [a]
    ... ... @@ -116,7 +135,7 @@ import Prelude hiding (break, cycle, drop, dropWhile,
    116 135 
                                           last, length, map, repeat, reverse,
    117 136 
                                           scanl, scanl1, scanr, scanr1, span,
    118 137 
                                           splitAt, tail, take, takeWhile,
    119 
    -                                      unzip, zip, zipWith, (!!), Applicative(..))
    138 
    +                                      unzip, unzip3, zip, zip3, zipWith, zipWith3, (!!), Applicative(..))
    120 139 
     import qualified Prelude
    121 140
    122 141 
     import           Control.Applicative (Applicative (..), Alternative (many))
    ... ... @@ -560,12 +579,97 @@ isPrefixOf (y:ys) (x :| xs) = (y == x) && List.isPrefixOf ys xs
    560 579 
       | otherwise = error "NonEmpty.!! negative index"
    561 580 
     infixl 9 !!
    562 581
    582 
    +-- | The 'zip3' function takes three streams and returns a stream of
    583 
    +-- corresponding triples.
    584 
    +zip3 :: NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty (a, b, c)
    585 
    +zip3 (x :| xs) (y :| ys) (z :| zs) = (x, y, z) :| List.zip3 xs ys zs
    586 
    +
    587 
    +-- | The 'zip4' function takes four streams and returns a stream of
    588 
    +-- corresponding quadruples.
    589 
    +zip4 :: NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty (a, b, c, d)
    590 
    +zip4 (x :| xs) (y :| ys) (z :| zs) (t :| ts) = (x, y, z, t) :| List.zip4 xs ys zs ts
    591 
    +
    592 
    +-- | The 'zip5' function takes five streams and returns a stream of
    593 
    +-- corresponding quintuples.
    594 
    +zip5 :: NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty (a, b, c, d, e)
    595 
    +zip5 (x :| xs) (y :| ys) (z :| zs) (t :| ts) (u :| us) = (x, y, z, t, u) :| List.zip5 xs ys zs ts us
    596 
    +
    597 
    +-- | The 'zip6' function takes six streams and returns a stream of
    598 
    +-- corresponding sextuples.
    599 
    +zip6 :: NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty (a, b, c, d, e, f)
    600 
    +zip6 (x :| xs) (y :| ys) (z :| zs) (t :| ts) (u :| us) (v :| vs) = (x, y, z, t, u, v) :| List.zip6 xs ys zs ts us vs
    601 
    +
    602 
    +-- | The 'zip7' function takes seven streams and returns a stream of
    603 
    +-- corresponding septuples.
    604 
    +zip7 :: NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g -> NonEmpty (a, b, c, d, e, f, g)
    605 
    +zip7 (x :| xs) (y :| ys) (z :| zs) (t :| ts) (u :| us) (v :| vs) (w :| ws) = (x, y, z, t, u, v, w) :| List.zip7 xs ys zs ts us vs ws
    606 
    +
    607 
    +-- | The 'zipWith3' function generalizes 'zip3'. Rather than tupling
    608 
    +-- the elements, the elements are combined using the function
    609 
    +-- passed as the first argument.
    610 
    +zipWith3 :: (a -> b -> c -> d) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d
    611 
    +zipWith3 f (x :| xs) (y :| ys) (z :| zs) = f x y z :| List.zipWith3 f xs ys zs
    612 
    +
    613 
    +-- | The 'zipWith4' function generalizes 'zip4'. Rather than tupling
    614 
    +-- the elements, the elements are combined using the function
    615 
    +-- passed as the first argument.
    616 
    +zipWith4 :: (a -> b -> c -> d -> e) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e
    617 
    +zipWith4 f (x :| xs) (y :| ys) (z :| zs) (t :| ts) = f x y z t :| List.zipWith4 f xs ys zs ts
    618 
    +
    619 
    +-- | The 'zipWith5' function generalizes 'zip5'. Rather than tupling
    620 
    +-- the elements, the elements are combined using the function
    621 
    +-- passed as the first argument.
    622 
    +zipWith5 :: (a -> b -> c -> d -> e -> f) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f
    623 
    +zipWith5 f (x :| xs) (y :| ys) (z :| zs) (t :| ts) (u :| us) = f x y z t u :| List.zipWith5 f xs ys zs ts us
    624 
    +
    625 
    +-- | The 'zipWith6' function generalizes 'zip6'. Rather than tupling
    626 
    +-- the elements, the elements are combined using the function
    627 
    +-- passed as the first argument.
    628 
    +zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g
    629 
    +zipWith6 f (x :| xs) (y :| ys) (z :| zs) (t :| ts) (u :| us) (v :| vs) = f x y z t u v :| List.zipWith6 f xs ys zs ts us vs
    630 
    +
    631 
    +-- | The 'zipWith7' function generalizes 'zip7'. Rather than tupling
    632 
    +-- the elements, the elements are combined using the function
    633 
    +-- passed as the first argument.
    634 
    +zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g -> NonEmpty h
    635 
    +zipWith7 f (x :| xs) (y :| ys) (z :| zs) (t :| ts) (u :| us) (v :| vs) (w :| ws) = f x y z t u v w :| List.zipWith7 f xs ys zs ts us vs ws
    636 
    +
    563 637 
     -- | The 'unzip' function is the inverse of the 'zip' function.
    564 638 
     unzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
    565 639 
     unzip ((a, b) :| asbs) = (a :| as, b :| bs)
    566 640 
       where
    567 641 
         (as, bs) = List.unzip asbs
    568 642
    643 
    +-- | The 'unzip3' function is the inverse of the 'zip3' function.
    644 
    +unzip3 :: NonEmpty (a, b, c) -> (NonEmpty a, NonEmpty b, NonEmpty c)
    645 
    +unzip3 ((a, b, c) :| asbscs) = (a :| as, b :| bs, c :| cs)
    646 
    +  where
    647 
    +    (as, bs, cs) = List.unzip3 asbscs
    648 
    +
    649 
    +-- | The 'unzip4' function is the inverse of the 'zip4' function.
    650 
    +unzip4 :: NonEmpty (a, b, c, d) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d)
    651 
    +unzip4 ((a, b, c, d) :| asbscsds) = (a :| as, b :| bs, c :| cs, d :| ds)
    652 
    +  where
    653 
    +    (as, bs, cs, ds) = List.unzip4 asbscsds
    654 
    +
    655 
    +-- | The 'unzip5' function is the inverse of the 'zip5' function.
    656 
    +unzip5 :: NonEmpty (a, b, c, d, e) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e)
    657 
    +unzip5 ((a, b, c, d, e) :| asbscsdses) = (a :| as, b :| bs, c :| cs, d :| ds, e :| es)
    658 
    +  where
    659 
    +    (as, bs, cs, ds, es) = List.unzip5 asbscsdses
    660 
    +
    661 
    +-- | The 'unzip6' function is the inverse of the 'zip6' function.
    662 
    +unzip6 :: NonEmpty (a, b, c, d, e, f) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e, NonEmpty f)
    663 
    +unzip6 ((a, b, c, d, e, f) :| asbscsdsesfs) = (a :| as, b :| bs, c :| cs, d :| ds, e :| es, f :| fs)
    664 
    +  where
    665 
    +    (as, bs, cs, ds, es, fs) = List.unzip6 asbscsdsesfs
    666 
    +
    667 
    +-- | The 'unzip7' function is the inverse of the 'zip7' function.
    668 
    +unzip7 :: NonEmpty (a, b, c, d, e, f, g) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e, NonEmpty f, NonEmpty g)
    669 
    +unzip7 ((a, b, c, d, e, f, g) :| asbscsdsesfsgs) = (a :| as, b :| bs, c :| cs, d :| ds, e :| es, f :| fs, g :| gs)
    670 
    +  where
    671 
    +    (as, bs, cs, ds, es, fs, gs) = List.unzip7 asbscsdsesfsgs
    672 
    +
    569 673 
     -- | The 'nub' function removes duplicate elements from a list. In
    570 674 
     -- particular, it keeps only the first occurrence of each element.
    571 675 
     -- (The name 'nub' means \'essence\'.)

  • testsuite/tests/interface-stability/base-exports.stdout
    ... ... @@ -1507,9 +1507,24 @@ module Data.List.NonEmpty where
    1507 1507 
       unfold :: forall a b. (a -> (b, GHC.Internal.Maybe.Maybe a)) -> a -> NonEmpty b
    1508 1508 
       unfoldr :: forall a b. (a -> (b, GHC.Internal.Maybe.Maybe a)) -> a -> NonEmpty b
    1509 1509 
       unzip :: forall a b. NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
    1510 
    +  unzip3 :: forall a b c. NonEmpty (a, b, c) -> (NonEmpty a, NonEmpty b, NonEmpty c)
    1511 
    +  unzip4 :: forall a b c d. NonEmpty (a, b, c, d) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d)
    1512 
    +  unzip5 :: forall a b c d e. NonEmpty (a, b, c, d, e) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e)
    1513 
    +  unzip6 :: forall a b c d e f. NonEmpty (a, b, c, d, e, f) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e, NonEmpty f)
    1514 
    +  unzip7 :: forall a b c d e f g. NonEmpty (a, b, c, d, e, f, g) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e, NonEmpty f, NonEmpty g)
    1510 1515 
       xor :: NonEmpty GHC.Internal.Types.Bool -> GHC.Internal.Types.Bool
    1511 1516 
       zip :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
    1517 
    +  zip3 :: forall a b c. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty (a, b, c)
    1518 
    +  zip4 :: forall a b c d. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty (a, b, c, d)
    1519 
    +  zip5 :: forall a b c d e. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty (a, b, c, d, e)
    1520 
    +  zip6 :: forall a b c d e f. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty (a, b, c, d, e, f)
    1521 
    +  zip7 :: forall a b c d e f g. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g -> NonEmpty (a, b, c, d, e, f, g)
    1512 1522 
       zipWith :: forall a b c. (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
    1523 
    +  zipWith3 :: forall a b c d. (a -> b -> c -> d) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d
    1524 
    +  zipWith4 :: forall a b c d e. (a -> b -> c -> d -> e) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e
    1525 
    +  zipWith5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f
    1526 
    +  zipWith6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g
    1527 
    +  zipWith7 :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g -> NonEmpty h
    1513 1528
    1514 1529 
     module Data.Maybe where
    1515 1530 
       -- Safety: Safe

  • testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs
    ... ... @@ -1507,9 +1507,24 @@ module Data.List.NonEmpty where
    1507 1507 
       unfold :: forall a b. (a -> (b, GHC.Internal.Maybe.Maybe a)) -> a -> NonEmpty b
    1508 1508 
       unfoldr :: forall a b. (a -> (b, GHC.Internal.Maybe.Maybe a)) -> a -> NonEmpty b
    1509 1509 
       unzip :: forall a b. NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
    1510 
    +  unzip3 :: forall a b c. NonEmpty (a, b, c) -> (NonEmpty a, NonEmpty b, NonEmpty c)
    1511 
    +  unzip4 :: forall a b c d. NonEmpty (a, b, c, d) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d)
    1512 
    +  unzip5 :: forall a b c d e. NonEmpty (a, b, c, d, e) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e)
    1513 
    +  unzip6 :: forall a b c d e f. NonEmpty (a, b, c, d, e, f) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e, NonEmpty f)
    1514 
    +  unzip7 :: forall a b c d e f g. NonEmpty (a, b, c, d, e, f, g) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e, NonEmpty f, NonEmpty g)
    1510 1515 
       xor :: NonEmpty GHC.Internal.Types.Bool -> GHC.Internal.Types.Bool
    1511 1516 
       zip :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
    1517 
    +  zip3 :: forall a b c. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty (a, b, c)
    1518 
    +  zip4 :: forall a b c d. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty (a, b, c, d)
    1519 
    +  zip5 :: forall a b c d e. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty (a, b, c, d, e)
    1520 
    +  zip6 :: forall a b c d e f. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty (a, b, c, d, e, f)
    1521 
    +  zip7 :: forall a b c d e f g. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g -> NonEmpty (a, b, c, d, e, f, g)
    1512 1522 
       zipWith :: forall a b c. (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
    1523 
    +  zipWith3 :: forall a b c d. (a -> b -> c -> d) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d
    1524 
    +  zipWith4 :: forall a b c d e. (a -> b -> c -> d -> e) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e
    1525 
    +  zipWith5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f
    1526 
    +  zipWith6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g
    1527 
    +  zipWith7 :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g -> NonEmpty h
    1513 1528
    1514 1529 
     module Data.Maybe where
    1515 1530 
       -- Safety: Safe

  • testsuite/tests/interface-stability/base-exports.stdout-mingw32
    ... ... @@ -1507,9 +1507,24 @@ module Data.List.NonEmpty where
    1507 1507 
       unfold :: forall a b. (a -> (b, GHC.Internal.Maybe.Maybe a)) -> a -> NonEmpty b
    1508 1508 
       unfoldr :: forall a b. (a -> (b, GHC.Internal.Maybe.Maybe a)) -> a -> NonEmpty b
    1509 1509 
       unzip :: forall a b. NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)
    1510 
    +  unzip3 :: forall a b c. NonEmpty (a, b, c) -> (NonEmpty a, NonEmpty b, NonEmpty c)
    1511 
    +  unzip4 :: forall a b c d. NonEmpty (a, b, c, d) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d)
    1512 
    +  unzip5 :: forall a b c d e. NonEmpty (a, b, c, d, e) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e)
    1513 
    +  unzip6 :: forall a b c d e f. NonEmpty (a, b, c, d, e, f) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e, NonEmpty f)
    1514 
    +  unzip7 :: forall a b c d e f g. NonEmpty (a, b, c, d, e, f, g) -> (NonEmpty a, NonEmpty b, NonEmpty c, NonEmpty d, NonEmpty e, NonEmpty f, NonEmpty g)
    1510 1515 
       xor :: NonEmpty GHC.Internal.Types.Bool -> GHC.Internal.Types.Bool
    1511 1516 
       zip :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
    1517 
    +  zip3 :: forall a b c. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty (a, b, c)
    1518 
    +  zip4 :: forall a b c d. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty (a, b, c, d)
    1519 
    +  zip5 :: forall a b c d e. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty (a, b, c, d, e)
    1520 
    +  zip6 :: forall a b c d e f. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty (a, b, c, d, e, f)
    1521 
    +  zip7 :: forall a b c d e f g. NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g -> NonEmpty (a, b, c, d, e, f, g)
    1512 1522 
       zipWith :: forall a b c. (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
    1523 
    +  zipWith3 :: forall a b c d. (a -> b -> c -> d) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d
    1524 
    +  zipWith4 :: forall a b c d e. (a -> b -> c -> d -> e) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e
    1525 
    +  zipWith5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f
    1526 
    +  zipWith6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g
    1527 
    +  zipWith7 :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> NonEmpty d -> NonEmpty e -> NonEmpty f -> NonEmpty g -> NonEmpty h
    1513 1528
    1514 1529 
     module Data.Maybe where
    1515 1530 
       -- Safety: Safe

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.haskell.org. Manage all notifications · Help