Last week, I announced Blunt, a tool for converting Haskell expressions between the pointfree and pointful styles. I have a secret, though: I don’t like the pointfree style.

I don’t like it because I think it’s hard to read. Pointfree expressions don’t mention all of their arguments, which forces you to know the arity of the functions they call. And the . operator reads from right to left, meaning your eyes have to jump back and forth when reading code that uses it.

I think Haskell can do better. That’s why I created Flow, a library for writing more understandable Haskell. Flow provides alternatives to common operators in the base package, like function application with $ and function composition with .. Here’s an overview of the functions and operators it defines:

Flow borrows from F#, which defines pipe forward (|>) and pipe backward (<|) operators. It also borrows the compose forward (>>) and compose backward (<<) operators, although I renamed them since Haskell already defines >>.

In addition to operators, Flow provides functions for application and composition. I did this for two reasons: One, every operator should have a name. And two, regular functions are clearer when used with higher-order functions. Compare map (apply 2) to map ($ 2) for example.

Given all that, how can Flow be used to write more understandable Haskell? Let’s look at problem 8 from Project Euler as an example.

Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?

I wrote a solution years ago when I was learning Haskell. Recently I re-wrote that solution in a more idiomatic, pointfree way. I’ll present both solutions here and convert them to using Flow.

The first part of the solution is the takes function. It slides a window of the given size over a list. Let’s see an example.

>>> takes 2 [1 .. 3]
[[1,2],[2,3],[3],[]]

When I first wrote this function, I used explicit recursion. There’s nothing wrong with this per se, but most experienced Haskellers wouldn’t write it this way.

takes :: Int -> [a] -> [[a]]
takes _ [] = [[]]
takes n xs@(_ : ys) = take n xs : takes n ys

Since then, I learned about the pointfree style and the tails function. Using both leads to the most idiomatic definition of this function.

takes n = map (take n) . tails

How can you rewrite this function with Flow, and what does it get you? You have two options for converting. If you want to keep the pointfree style, you can use the compose forward operator.

takes n = tails .> map (take n)

If, like me, you don’t want to keep the pointfree style, you can use the pipe forward operator.

takes n xs = xs |> tails |> map (take n)

Either way, what you get is a function that reads naturally from left to right. And if you use the pipe forward operator, your function looks like something you might have written in GHCi. Consider the following interpreter session.

>>> let xs = [1 .. 3]
>>> xs
[1,2,3]
>>> xs |> tails
<interactive>:3:7: Not in scope: ‘tails’
>>> import Data.List
>>> xs |> tails
[[1,2,3],[2,3],[3],[]]
>>> xs |> tails |> map (take n)
<interactive>:6:26: Not in scope: ‘n’
>>> let n = 2
>>> n
2
>>> xs |> tails |> map (take n)
[[1,2],[2,3],[3],[]]

This shows how Flow helps you build up complex expressions one piece at a time. So let’s move on to the next piece of this problem, the euler8 function. Given a window of size n and a string, it returns the largest product of n consecutive numbers in the string. Let’s take a look at a simple example.

>>> euler8 2 "123"
6

The first time I wrote this function, I didn’t know about function composition. I wrote it with a bunch of parentheses. I quickly learned about the $ operator to remove them.

euler8 :: Int -> String -> Int
euler8 n x
    = maximum
    $ map product
    $ takes n
    $ map digitToInt
    $ filter isDigit x

Now that I know about the . operator, I would write this function differently. Like the pointfree definition of takes, this is the most idiomatic way to write this function.

euler8 n
    = maximum
    . map product
    . takes n
    . map digitToInt
    . filter isDigit

In spite of that, this looks backwards to me. You have to read it starting from the bottom in order to understand it. With Flow, you can read it naturally from top to bottom.

euler8 n x = x
    |> filter isDigit
    |> map digitToInt
    |> takes n
    |> map product
    |> maximum

So that’s a quick overview of what Flow does and why you might want it. If you’re interested, please check out Flow’s project page.