What do I lose by setting up zipWithPadding like this? (alternate zipWith in Haskell)

Question

This problem came up when I was trying to zip through lists of different length and I didn't want them to be cut by the shortest one. It was in a context where the list had integers that I wanted to add or multiply. My problem is how to set up the type variables so that it can be more general.

zipWithPadding :: a -> (a -> a -> a) -> [a] -> [a] -> [a]
zipWithPadding n f = go n f
  where
    go n f [] a  = [f n x | x <- a]
    go n f a []  = [f n x | x <- a]
    go n f (x:xs) (y:ys) = f x y : go n f xs ys

Currently, because the element to pad the lists with has to be speficied, I have to write them this way, but it begs the question of whether it needs to be custom made for each context, or simply repurposed with higher order functions.

Edit: I would like to thank Chris in the comments for the help. It made the example at the bottom possible by changing the above solution into this:

zipPadWith :: a -> b -> (a -> b -> c) -> [a] -> [b] -> [c]
zipPadWith n m f = go n m f
  where
    go n _ f [] a          = [f n x | x <- a]
    go _ m f a []          = [f x m | x <- a]
    go n m f (x:xs) (y:ys) = f x y : go n m f xs ys

The example being:

transposeWith :: a -> [[a]] -> [[a]]
transposeWith n []       = []
transposeWith n (ms:mss) = zipPadWith n [] (:) ms (transposeWith n mss)

It transposes the list of lists without cutting content.

Suggestion: you may wish to provide two "padding" values to your `zipPadWith` function. One to pad the left list with, and one to pad the right list with. If you do, you can end up with a type signature like so: `zipPadWith :: t1 -> t2 -> (t1 -> t2 -> a) -> [t1] -> [t2] -> [a]` You could then maybe specialize this for `zipPadWith1` which takes one default "padding" value: `zipPadWith1 n = zipPadWith n n` — Chris, Nov 05 '22 at 00:26
You could even pass for "padding" functions that operate on the element in the longer list to generate a value. `zipPadWith :: (t1 -> t2) -> (t2 -> t1) -> (t2 -> t1 -> a) -> [t2] -> [t1] -> [a]` — Chris, Nov 05 '22 at 00:54

score 1 · Accepted Answer · answered Nov 05 '22 at 05:59

If we implement zipPadWith in the following manner, the application of the default value as both arguments to f constrains the signature to a -> (a -> a -> a) -> [a] -> [a] -> [a].

zipPadWith _ _ [] [] = []
zipPadWith n f (x:xs) (y:ys) = f x y : zipPadWith n f xs ys
zipPadWith n f (x:xs) [] = f x n : zipPadWith n f xs []
zipPadWith n f [] (y:ys) = f n y : zipPadWith n f [] ys

However, if the function takes two default arguments, one to use if the left list falls short, and one to use if the right list falls short, the type is not constrained, and can be a -> b -> (a -> b -> c) -> [a] -> [b] -> [c].

zipPadWith _ _ _ [] [] = []
zipPadWith n1 n2 f (x:xs) (y:ys) = f x y : zipPadWith n1 n2 f xs ys
zipPadWith n1 n2 f (x:xs) [] = f x n2 : zipPadWith n1 n2 f xs []
zipPadWith n1 n2 f [] (y:ys) = f n1 y : zipPadWith n1 n2 f [] ys

What do I lose by setting up zipWithPadding like this? (alternate zipWith in Haskell)

1 Answers1