Sections – Haskell

Haskell is a functional programming language that thrives on concise and expressive code. One of the lesser-known yet elegant features of Haskell is sections, which offer a shorthand way to define functions. If you’ve ever wondered what’s going on when you see partial application involving operators like (+1) or (2*), you’re in the realm of sections.

This article will break down what sections are, how they work, and how you can use them to write cleaner and more intuitive Haskell code.

What Are Sections?

In Haskell, sections are a way to partially apply infix operators. They allow you to create functions by specifying one operand of a binary operator, leaving the other operand unspecified. This results in a function that takes the missing operand and applies the operator to it.

Syntax:

A section wraps an operator and one of its operands in parentheses:

• Left Section: (op x) becomes a function equivalent to \y -> x op y.
• Right Section: (x op) becomes a function equivalent to \y -> y op x.

Examples:

Left Section:

(+ 1) 5 -- Equivalent to 1 + 5
-- Result: 6

Here, (+ 1) is a function that adds 1 to its argument.

Right Section:

(2 *) 3 -- Equivalent to 2 * 3
-- Result: 6

Here, (2 *) is a function that multiplies its argument by 2.

Why Use Sections?

1. Simplify Function Definitions

Sections provide a concise way to define functions without writing explicit lambda expressions.

Example:

-- Using a lambda:
addOne = \x -> x + 1

-- Using a section:
addOne = (+ 1)

2. Improve Readability

Sections make it clear which operand is fixed and what the function is doing. Compare:

-- With a lambda:
double = \x -> 2 * x

-- With a section:
double = (2 *)

3. Compose Functions Easily

Since sections create functions, they work seamlessly with Haskell’s function composition operator (.).

Example:

incrementAndDouble = (+ 1) . (2 *)
-- Equivalent to: \x -> (x * 2) + 1

How Sections Work with Different Operators

Arithmetic Operators

You can use sections with any binary arithmetic operator:

Addition:

increment = (+ 1) -- Adds 1 to its argument

Multiplication:

double = (2 *) -- Multiplies its argument by 2

Comparison Operators

Sections are also useful with comparison operators:

Greater than:

isGreaterThan5 = (> 5)
-- Checks if a number is greater than 5

Less than:

isLessThan10 = (< 10)
-- Checks if a number is less than 10

Logical Operators

You can use sections with logical operators to create partial logical expressions:

AND:

isTrueAnd = (True &&)
-- Returns True only if its argument is True

OR:

isFalseOr = (False ||)
-- Returns its argument, since False doesn't affect OR

List Operators

Sections work well with operators that manipulate lists:

Append:

appendHello = (++ "Hello")
-- Appends "Hello" to the end of a string

Cons:

prependOne = (1 :)
-- Prepends 1 to the beginning of a list

Limitations and Gotchas

1. Sections Require Parentheses

You must enclose the operator and its operand in parentheses to create a section. Omitting the parentheses leads to syntax errors or unintended behavior.

Incorrect:

+ 1
-- Error: Invalid syntax

Correct:

(+ 1)

2. Not All Operators Are Associative

Some operators, like subtraction or division, depend on operand order. Pay attention to the direction of application:

Left Section:

(5 -) 2 -- Equivalent to 5 - 2
-- Result: 3

Right Section:

(- 5) 2 -- Equivalent to 2 - 5
-- Result: -3

3. No Partial Application for Prefix Functions

Sections only work with infix operators. You cannot create sections with standard prefix functions.

Example:

not True -- Works, but you can't partially apply 'not' like an operator

Practical Applications of Sections

Filtering Lists

Sections simplify list filtering:

greaterThan5 = filter (> 5)
-- Filters elements greater than 5 from a list
greaterThan5 [3, 7, 9, 2]
-- Result: [7, 9]

Map Transformations

Sections can define transformations concisely:

incrementAll = map (+ 1)
incrementAll [1, 2, 3]
-- Result: [2, 3, 4]

Function Composition

Sections integrate smoothly into function pipelines:

process = map (+ 1) . filter (> 5)
process [3, 6, 9]
-- Result: [7, 10]

Conclusion

Sections in Haskell are a powerful feature that simplifies the definition and use of functions involving infix operators. By allowing partial application in a clean, readable way, sections enable concise and expressive code.

Understanding sections will not only improve your Haskell skills but also make your code easier to read and maintain. Next time you write a function, consider whether a section could simplify your expression—you might be surprised at the elegance it brings!