Eta Conversion – Haskell

Eta reduction and eta expansion are terms you might encounter when working with Haskell or functional programming. These concepts are rooted in lambda calculus and are essential for understanding how Haskell functions can be simplified or transformed. By learning about eta reduction and expansion, you can write cleaner, more concise code and better understand how Haskell’s type system and functions work.

What is Eta Conversion?

In lambda calculus, eta conversion refers to the process of simplifying or expanding a function by adding or removing an argument. This can either make a function more concise (eta reduction) or more explicit (eta expansion). The two processes maintain the same meaning and functionality of the function.

• Eta Reduction: Removing unnecessary arguments from a function definition.
• Eta Expansion: Adding explicit arguments to make the function definition more verbose but equivalent.

Eta Reduction

Definition

Eta reduction simplifies a function by removing an explicit argument if the function does nothing other than apply another function to that argument.

Rule

For a function f, the transformation:

λx → g x ≡ g

is valid if g does not depend on x in any other way except as an argument directly applied to g.

Haskell Example

Consider a function:

addTwo :: Int -> Int
addTwo x = (+ 2) x

Here, addTwo is just applying the function (+ 2) to its argument x. Using eta reduction, we can simplify this to:

addTwo :: Int -> Int
addTwo = (+ 2)

The two forms are equivalent because both define a function that takes an integer and adds 2 to it.

Benefits

• Conciseness: Eta reduction removes redundant arguments, making code cleaner.
• Readability: It highlights the essence of the function, focusing on what it does rather than unnecessary mechanics.

Eta Expansion

Definition

Eta expansion is the reverse of eta reduction. It involves explicitly introducing an argument to a function, which may be required for type compatibility or clarity in certain contexts.

Rule

For a function g, the transformation:

g ≡ λx → g x

is valid.

Haskell Example

Suppose we have:

addTwo :: Int -> Int
addTwo = (+ 2)

We can expand it as:

addTwo :: Int -> Int
addTwo = \x -> (+ 2) x

Although these two forms are equivalent, the expanded version makes it explicit that addTwo is a function expecting an argument.

When to Use Eta Expansion

• Type Constraints: Sometimes, eta expansion is required to make a function conform to a specific type signature, especially in polymorphic or higher-order function contexts.
• Readability: When explicit arguments make the intention of the function clearer to readers.

Practical Use Cases

1. Point-Free Style

Eta reduction is central to writing functions in point-free style, where functions are composed without explicitly mentioning their arguments.

Example

Using eta reduction:

incrementAll :: [Int] -> [Int]
incrementAll xs = map (+ 1) xs

Can be written in point-free style as:

incrementAll :: [Int] -> [Int]
incrementAll = map (+ 1)

Point-free style is often used in Haskell for concise and elegant code, though it’s best used when it enhances readability.

2. Higher-Order Functions

Eta expansion can help when passing functions as arguments to higher-order functions or when working with partially applied functions.

Example

Suppose a higher-order function requires a function that takes an argument explicitly:

applyFunction :: (Int -> Int) -> Int -> Int
applyFunction f x = f x

Using eta expansion, you can pass an explicitly expanded function:

applyFunction (\x -> (+ 1) x) 5

This is equivalent to passing:

applyFunction (+ 1) 5

Eta Laws in Haskell

Eta reduction and expansion rely on the idea that a function is entirely defined by what it does to its arguments. The equivalence is based on extensionality, which states:

f x = g x ∀x   ⟹  f = g

In Haskell, this is guaranteed for functions without side effects, thanks to its pure functional nature. However, for functions involving effects (like those in the IO monad), caution is needed, as eta reduction may not preserve behavior.

Common Pitfalls

1. Overuse of Eta Reduction

While eta reduction makes code concise, overuse can obscure intent. Consider readability:

processList = map (* 2)

Versus:

processList xs = map (* 2) xs

For someone new to Haskell, the second version may be easier to understand.

2. Eta Reduction and Laziness

Eta reduction should not affect behavior in Haskell because the language is lazy. However, in edge cases involving partial functions or bottom values (undefined), the transformations may behave differently.

Summary

• Eta Reduction: Simplifies a function by removing unnecessary arguments.
  • Example: \x -> f x → f
• Eta Expansion: Introduces explicit arguments to a function.
  • Example: f → \x -> f x

When to Use:

• Use eta reduction for concise, point-free style code.
• Use eta expansion to conform to type signatures or improve clarity in higher-order function contexts.

Understanding eta reduction and expansion helps you write clean, elegant Haskell code while adhering to its functional programming principles.

💡 Helpful References

Effective Haskell - Writing Functions
https://www.pragprog.com/titles/rshaskell/effective-haskell/