Restore zip/unzip

Author: garyb

bower.json

@@ -17,7 +17,8 @@
   ],
   "dependencies": {
     "purescript-foldable-traversable": "~0.4.0",
-    "purescript-st": "~0.1.0"
+    "purescript-st": "~0.1.0",
+    "purescript-tuples": "~0.4.0"
   },
   "devDependencies": {
     "purescript-assert": "~0.1.0",

docs/Data.Array.md

@@ -472,6 +472,24 @@ zipWithA :: forall m a b c. (Applicative m) => (a -> b -> m c) -> Array a -> Arr
 A generalization of `zipWith` which accumulates results in some `Applicative`
 functor.
 
+#### `zip`
+
+``` purescript
+zip :: forall a b. Array a -> Array b -> Array (Tuple a b)
+```
+
+Rakes two lists and returns a list of corresponding pairs.
+If one input list is short, excess elements of the longer list are discarded.
+
+#### `unzip`
+
+``` purescript
+unzip :: forall a b. Array (Tuple a b) -> Tuple (Array a) (Array b)
+```
+
+Transforms a list of pairs into a list of first components and a list of
+second components.
+
 #### `foldM`
 
 ``` purescript

src/Data/Array.purs

@@ -67,20 +67,23 @@ module Data.Array
 
   , zipWith
   , zipWithA
+  , zip
+  , unzip
 
   , foldM
   ) where
 
 import Control.Alt (Alt, (<|>))
 import Control.Alternative (Alternative)
+import Control.Lazy (Lazy, defer)
 import Control.MonadPlus (MonadPlus)
 import Control.Plus (Plus)
-import Control.Lazy (Lazy, defer)
 import Data.Foldable (Foldable, foldr)
 import Data.Functor.Invariant (Invariant, imapF)
 import Data.Maybe (Maybe(..), maybe, isJust)
 import Data.Monoid (Monoid, mempty)
 import Data.Traversable (Traversable, traverse, sequence)
+import Data.Tuple (Tuple(..))
 
 --------------------------------------------------------------------------------
 -- Array creation --------------------------------------------------------------
@@ -456,6 +459,17 @@ foreign import zipWith :: forall a b c. (a -> b -> c) -> Array a -> Array b -> A
 zipWithA :: forall m a b c. (Applicative m) => (a -> b -> m c) -> Array a -> Array b -> m (Array c)
 zipWithA f xs ys = sequence (zipWith f xs ys)
 
+-- | Rakes two lists and returns a list of corresponding pairs.
+-- | If one input list is short, excess elements of the longer list are discarded.
+zip :: forall a b. Array a -> Array b -> Array (Tuple a b)
+zip = zipWith Tuple
+
+-- | Transforms a list of pairs into a list of first components and a list of
+-- | second components.
+unzip :: forall a b. Array (Tuple a b) -> Tuple (Array a) (Array b)
+unzip = uncons' (\_ -> Tuple [] []) \(Tuple a b) ts -> case unzip ts of
+  Tuple as bs -> Tuple (a : as) (b : bs)
+
 --------------------------------------------------------------------------------
 -- Folding ---------------------------------------------------------------------
 --------------------------------------------------------------------------------

test/Test/Data/Array.purs

@@ -4,6 +4,7 @@ import Console (log)
 import Data.Array
 import Data.Maybe (Maybe(..), isNothing)
 import Data.Maybe.Unsafe (fromJust)
+import Data.Tuple (Tuple(..))
 import Test.Assert (assert)
 
 testArray = do
@@ -220,7 +221,15 @@ testArray = do
   log "zipWith should use the specified function to zip two lists together"
   assert $ zipWith (\x y -> [show x, y]) [1, 2, 3] ["a", "b", "c"] == [["1", "a"], ["2", "b"], ["3", "c"]]
 
-  -- zipWithA
+  log "zipWithA should use the specified function to zip two lists together"
+  assert $ zipWithA (\x y -> Just $ Tuple x y) [1, 2, 3] ["a", "b", "c"] == Just [Tuple 1 "a", Tuple 2 "b", Tuple 3 "c"]
+
+  log "zip should use the specified function to zip two lists together"
+  assert $ zip [1, 2, 3] ["a", "b", "c"] == [Tuple 1 "a", Tuple 2 "b", Tuple 3 "c"]
+
+  log "unzip should deconstruct a list of tuples into a tuple of lists"
+  assert $ unzip [Tuple 1 "a", Tuple 2 "b", Tuple 3 "c"] == Tuple [1, 2, 3] ["a", "b", "c"]
+
   -- foldM
 
 nil :: Array Int