The purpose of eta reduction (also written $$\eta$$-reduction) is to drop an abstraction over a function to simplify it. This is possible when there is nothing more that a function can do to its argument. For example, imagine that we have a simple function $$f\ x = g\ x$$. Both $$g$$ and $$f$$ take the same argument, $$x$$, and the function application function results in the same value (specified by the equality symbol). Since both $$f$$ and $$g$$ take the same argument and produce the same result, we can simplify the equation to just $$f = g$$. In lambda calculus, this simplification is called $$\eta$$-reduction.

More precisely, $$\eta$$-reduction allows you to convert between $$\lambda x.(f\ x)$$ and $$f$$ whenever $$x$$ is not a free variable in $$f$$. That is, $$f = \lambda x(f\ x)$$. Let’s look at a more practical example from the book PureScript by Example.

In functional languages based on lambda calculus, all functions take exactly one argument. PureScript is no different. For example, consider the function insertEntry that inserts an entry into an address book. This function takes an Entry and an AddressBook as a parameter, and returns a new AddressBook with the entry parameter inserted into it. This function has a type signature of insertEntry :: Entry -> AddressBook -> AddressBook, which specifies that the function insertEntry takes parameters of type Entry and AddressBook and returns a result of AddressBook.

We make some simplifying assumptions here by assuming that AddressBook is implemented as a simple list. We can therefore use concatenation (or list construction) to implement insertEntry by concatenating the entry to the address book using the concatenation function Cons. This results in the following type signature and implementation for insertEntry.

insertEntry :: Entry -> AddressBook -> AddressBook
insertEntry entry book = Cons entry book


This function is implemented by passing the book and entry parameters to the Cons function to concatenate them together. If we remove the parameter book from both sides of the function definition, we end up with a function insertEntry entry and a function Cons entry. Both of these functions can still be called with book as a parameter. Since these two functions are equivalent and they take the same parameter, we can use $$\eta$$-reduction to completely eliminate the parameter book from the function definition.

insertEntry :: Entry -> AddressBook -> AddressBook
insertEntry entry = Cons entry


By the same reasoning, we can further reduce the function to remove the entry argument. This results in the following function:

insertEntry :: Entry -> AddressBook -> AddressBook
insertEntry = Cons


We now have a very simple implementation for insertEntry — it is just Cons on a list.