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.