Zip with default value instead of dropping values?

by

There is some structure to this problem, and here it comes. I’ll be using this stuff:

import Control.Applicative
import Data.Traversable
import Data.List

First up, lists-with-padding are a useful concept, so let’s have a type for them.

data Padme m = (:-) {padded :: [m], padder :: m} deriving (Show, Eq)

Next, I remember that the truncating-zip operation gives rise to an Applicative instance, in the library as newtype ZipList (a popular example of a non-Monad). The Applicative ZipList amounts to a decoration of the monoid given by infinity and minimum. Padme has a similar structure, except that its underlying monoid is positive numbers (with infinity), using one and maximum.

instance Applicative Padme where
  pure = ([] :-)
  (fs :- f) <*> (ss :- s) = zapp fs ss :- f s where
    zapp  []        ss        = map f ss
    zapp  fs        []        = map ($ s) fs
    zapp  (f : fs)  (s : ss)  = f s : zapp fs ss

I am obliged to utter the usual incantation to generate a default Functor instance.

instance Functor Padme where fmap = (<*>) . pure

Thus equipped, we can pad away! For example, the function which takes a ragged list of strings and pads them with spaces becomes a one liner.

deggar :: [String] -> [String]
deggar = transpose . padded . traverse (:- ' ')

See?

*Padme> deggar ["om", "mane", "padme", "hum"]
["om   ","mane ","padme","hum  "]

More Related Contents:

  1. Merging two lists in Haskell
  2. Removing syntactic sugar: List comprehension in Haskell
  3. Haskell finding mean of cubes of odd members Any ideas? [closed]
  4. Histogram in Haskell [closed]
  5. What is Haskell’s Stream Fusion
  6. What are paramorphisms?
  7. Using return vs. not using return in the list monad
  8. Cartesian product of infinite lists in Haskell
  9. Decrementing ranges in Haskell
  10. Replace individual list elements in Haskell?
  11. Using Haskell’s map function to calculate the sum of a list
  12. Need to partition a list into lists based on breaks in ascending order of elements (Haskell)
  13. Haskell Monad – How does Monad on list work?
  14. Is there a function to flatten a nested list of elements?
  15. Understanding a recursively defined list (fibs in terms of zipWith)
  16. Removing duplicates from a list in Haskell without elem
  17. Splitting a list of items into two lists of odd and even indexed items
  18. Counting unique elements in a list
  19. Unsequence Monad function within Haskell
  20. Grouping a list into lists of n elements in Haskell
  21. Getting started with Haskell
  22. Why are difference lists more efficient than regular concatenation in Haskell?
  23. Prolog: Filtering a list?
  24. How to generate all the permutations of elements in a list one at a time in Lisp?
  25. How to merge YAML arrays?
  26. Segregating Lists in Prolog
  27. How to increment a variable in functional programming?
  28. “bad words” filter [closed]
  29. Object oriented programming in Haskell
  30. Erlang lists with single numbers over 8?

Leave a Comment