Sanctuary: Add S.zip and S.zipWith

[svozza]

Create a type-safe version of zip and zipWith.

[davidchambers]

222 contains many interesting thoughts on this matter.

[svozza]

I'd completely forgotten about that! Guess we should close this then. I still think it's a useful function, I was only using it last week and had to go back to Ramda.

[davidchambers]

Let's reopen the discussion. The fact that it's now feasible to use Sanctuary without Ramda may tip the scales in favour of these functions' inclusion.

[gabejohnson]

How general do you want to go with this? A quick search of Hoogle shows a lot of zip related functions.

[davidchambers]

I think it would be okay to provide Array-specific functions:

zip :: Array a -> Array b -> Array (Pair a b)
zipWith :: (a -> b -> c) -> Array a -> Array b -> Array c

I'm not sure whether it's possible to provide these instead:

zip :: Foldable f => f a -> f b -> f (Pair a b)
zipWith :: Foldable f => (a -> b -> c) -> f a -> f b -> f c

I imagine this will require more than just Foldable. I haven't given the general form much thought.

[gabejohnson]

There's also zipWithM to consider.

[gabejohnson]

I think zip and zipWith could work withString as well.

[davidchambers]

Could you provide an example of applying zipWith to strings, @gabejohnson?

[gabejohnson]

// zipWith :: (String -> String -> String) -> String -> String -> [String]
joinWith(':', zipWith(a => b => `${a}+${b}`, 'hello', 'world')); // 'h+w:e+o:l+r:l+l:o+d'

[gabejohnson]

Don't ask me about the utility 😄

[davidchambers]

It's a different function, as it's monomorphic (we lost all the type variables). Let's not worry about the String-specific functions. ;)

[gabejohnson]

More generally:

// zipWith :: (String -> String -> a) -> String -> String -> [a]
const parseNat = parseInt(10);
sequence(Maybe, zipWith(a => b => lift2(add, parseNat(a), parseNat(b)), '1234', '56789'))
// Just([6, 8, 10, 12])

[gabejohnson]

@davidchambers I see your point. Was only fixing the type to illustrate.

[gabejohnson]

Or even _more_ generally:

// zipWith :: (a -> b -> c) -> List a -> List b -> List c
const parseNat = parseInt(10);
sequence(Maybe, zipWith(a => b => lift2(add, parseNat(a), Just(b)), '1234', [5, 6, 7, 8, 9]))
// Just([6, 8, 10, 12])

[safareli]

you can just apply toList to string and feed to zipWith

//    toList :: String -> [String]
const toList = s => s.split('')

[masaeedu]

Similarly, I'd want zip for StrMaps. It feels like there's some specialization of functors for which you can generally implement zip. Maybe Traversable?