Evaluating lambda functions requires using lots of brackets, which can be tedious and are a major source of error for evaluating expressions by hand. To simplify expressions, you can omit brackets when it is clear what the intention of the function is. Particularly, a function application can omit the brackets surrounding each individual parameter and assume the function is applied to the nearest argument. So, instead of expressing a function of three arguments as

$$ (((f : a1) : a2) : a3) $$

We can write

$$ f : a1 : a2 : a3 $$

A second simplification of notation is defining functions. Instead of defining a function using the full lambda syntax already described, we can drop the \(\lambda\) symbol and move any variables of the function definition to the left of the \(=\) sign. This means a function definition like

$$ \text{def } : f = \lambda\langle name \rangle. \langle expression \rangle $$

can be expressed as

$$ \text{def} : f \langle name \rangle = \langle expression \rangle $$

Using this syntactic sugar, we can express common functions like identity in a simplified format.

$$ \text{def} : identity = \lambda x.x $$

becomes

$$ \text{def} : identity : x = x $$

You will see this simplified syntax used to express lambda expressions more succinctly, especially when we start building more complex lambda expressions that rely on conditional logic or recursion.