Rotating args in Haskell and Ruby block style programming

I was writing some Haskell code and came across a function whose arguments weren't in the order I wanted. With most languages you're stuck, the library writer made a choice and now you have to live with it. But Haskell gives you more options ...

You may have encountered this before, for example with mapM_. The type signature of mapM_ is mapM_ :: (Monad m) => (a -> m b) -> [a] -> m (). But you can use flip on it and turn the type signature into flip mapM_ :: (Monad m) => [a] -> (a -> m b) -> m () which then lets you write code like this.

flip mapM_ [0..10] $ \n -> do
  print n
  print $ n * 3

Rubyists should see a familiar pattern there that looks a lot like a do/end block.

(0..10).each do |n|
  puts n
  puts n * 3
end

This is so useful that there is another function already defined that acts like mapM_ with its arguments flipped. It's called forM_ and as you might have guessed, it's type signature is forM_ :: (Monad m) => [a] -> (a -> m b) -> m ().

forM_ [0..10] $ \n -> do
  print n
  print $ n * 3

The flip function works very well for two argument functions, but what about three arguments or more? I was recently working with zipWithM_ :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m (). To use it as is, you'd have to write code like this.

zipWithM_ (\a b -> do { print (a + b); print (a + b * 3) }) [0..10] [4..]

Blecch. Hey, I want my code block at the end so I can work with it like I would in Ruby. I can't use flip here so what can I do? Enter in a new routine we'll call frot, for function rotate.

frot2 = flip
frot3 f b c a = f a b c

So what can we do with frot? Check out this little example.

-- frot2 works just like flip (obviously)

frot2 mapM_ [0..10] $ \n -> do
  print n
  print $ n * 3


-- original zipWithM_

ghci> :t zipWithM_
zipWithM_ :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m ()


-- We can alter zipWithM_ to act like it takes a block

ghci> :t frot3 zipWithM_
frot3 zipWithM_ :: (Monad m) => [a] -> [b] -> (a -> b -> m c) -> m ()

frot3 zipWithM_ [0..10] [4..] $ \a b -> do
  print (a + b)
  print (a + b * 3)


-- We can chain frot calls to alter the order - put [b] before [a]

ghci> :t frot2 $ frot3 zipWithM_
frot2 $ frot3 zipWithM_ :: (Monad m) => [b] -> [a] -> (a -> b -> m c) -> m ()

frot2 (frot3 zipWithM_) [4..] [0..10] $ \a b -> do
  print (a + b)
  print (a + b * 3)


-- We can continue rotating args

ghci> :t frot3 $ frot3 zipWithM_
frot3 $ frot3 zipWithM_ :: (Monad m) =>
                           [b] -> (a -> b -> m c) -> [a] -> m ()

frot3 (frot3 zipWithM_) [4..] (\a b -> do { print (a + b); print (a + b * 3)}) [0..10]


-- If we rotate enough, we're back where we started

ghci> :t frot3 $ frot3 $ frot3 zipWithM_
frot3 $ frot3 $ frot3 zipWithM_ :: (Monad m) =>
                                   (a -> b -> m c) -> [a] -> [b] -> m ()

The best part about this is that frot is not tied to zipWithM_. It can be used with any function. For example, we can alter the findWithDefault function from Data.Map just as easily.

ghci> :t findWithDefault
findWithDefault :: (Ord k) => a -> k -> Map k a -> a

ghci> :t frot3 $ frot3 findWithDefault
frot3 $ frot3 findWithDefault :: (Ord k) => Map k a -> a -> k -> a

-- Now we can partially apply and use

> let ds       = fromList [("new england", "patriots"), ("new york", "giants")]
>     findTeam = frot3 (frot3 findWithDefault) ds "no team"

> findTeam "peoria"
"no team"

> findTeam "new york"
"giants"

Update Fixed typo in frot3.

Update 2 Part 2 partially explains why this works in Haskell. Obtaining a full understanding is left as an exercise for the reader.