Point-free Style – Haskell

Haskell‘s point-free style, also known as tacit programming, is a way of writing functions without explicitly mentioning their arguments. Instead of specifying how arguments are manipulated, point-free style focuses on composing functions to achieve the desired result. This can lead to more concise and expressive code but may also make it harder to read for beginners.

In this article, we’ll explore the concept of point-free style, how it works, and when to use it effectively.

What is Point-Free Style?

In Haskell, functions are often defined by explicitly mentioning their arguments, called pointed style. Point-free style, on the other hand, eliminates these explicit arguments by expressing the function in terms of function composition and higher-order functions.

Pointed vs. Point-Free

Pointed Style:

addOne :: Int -> Int
addOne x = x + 1

Point-Free Style:

addOne :: Int -> Int
addOne = (+ 1)

Here, addOne is defined without explicitly mentioning the argument x.

How Does Point-Free Style Work?

Point-free style relies heavily on:

1. Function Composition (.): Combines two or more functions into one.

(f . g) x = f (g x)

2. Currying: Functions in Haskell are curried by default, allowing partial application.

add :: Int -> Int -> Int
add x y = x + y

add 5 :: Int -> Int  -- Partially applied function

By composing functions and leveraging currying, you can eliminate the need to explicitly mention arguments.

Examples of Point-Free Style

1. Simple Arithmetic

Pointed:

multiplyAndAdd :: Int -> Int -> Int
multiplyAndAdd x y = x * 2 + y

Point-free:

multiplyAndAdd :: Int -> Int -> Int
multiplyAndAdd = (+) . (* 2)

2. Function Composition

Pointed:

process :: String -> Int
process str = length (filter isAlpha str)

Point-free:

process :: String -> Int
process = length . filter isAlpha

3. Higher-order Functions

Pointed:

applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)

Point-free:

applyTwice :: (a -> a) -> a -> a
applyTwice f = f . f

4. Mapping Over a List

Pointed:

doubleAll :: [Int] -> [Int]
doubleAll xs = map (* 2) xs

Point-free:

doubleAll :: [Int] -> [Int]
doubleAll = map (* 2)

Advantages of Point-Free Style

1. Conciseness:
   • Reduces boilerplate by omitting explicit arguments.
   • Easier to focus on the transformation logic.
2. Clarity (in simple cases):
   • Highlights the composition of operations rather than the mechanics of argument passing.
3. Encourages Function Composition:
   • Leads to modular, reusable code by emphasizing the relationships between functions.

Disadvantages of Point-Free Style

1. Readability: Can become cryptic, especially for complex functions.

complicated = foldr (.) id . map (.)

While concise, this can be hard to understand at a glance.

2. Debugging: Point-free functions may obscure intermediate values, making debugging more challenging.

3. Not Always Feasible: Functions with multiple parameters or complex logic often require pointed style for clarity.

When to Use Point-Free Style

1. Simple Functions: Use point-free style for straightforward compositions.

toUppercase = map toUpper

2. Readability Matters: Avoid overly complex point-free expressions that harm readability.

3. Function Composition: When composing multiple transformations, point-free style can improve clarity.

cleanInput = map toLower . filter isAlpha

4. Intermediate Values: Prefer pointed style when intermediate values are significant.

compute xs = let doubled = map (* 2) xs
                filtered = filter (> 10) doubled
            in sum filtered

Refactoring to Point-Free Style

To refactor a pointed function to point-free style:

1. Identify arguments that are used directly in function calls.
2. Replace explicit arguments with compositions and partial applications.

Pointed:

squareSum :: [Int] -> Int
squareSum xs = sum (map (^ 2) xs)

Point-free:

squareSum :: [Int] -> Int
squareSum = sum . map (^ 2)

Conclusion

Point-free style in Haskell is a powerful way to write concise and expressive code by emphasizing function composition over argument manipulation. While it can lead to elegant solutions for simple problems, it’s essential to balance conciseness with readability, especially for more complex logic. By practicing point-free style, you’ll gain a deeper appreciation for Haskell’s functional nature and the beauty of composing functions.