Erlang functions and guards for beginners

Why Erlang function heads feel different

In many languages, you write one function body and branch inside it. In Erlang, you often write several clauses instead. Each clause can match a different shape or value range. This keeps the structure of the function visible at the top instead of hiding it deep inside nested logic.

For beginners, this is one of the most important style shifts. A good Erlang function reads almost like a list of cases. You can often understand what it does just by reading the function heads in order.

What a guard clause adds

A guard lets you narrow a function clause further. Pattern matching says what shape the input has. A guard says what extra condition must be true. That makes code more precise without making it noisy. Guards are especially useful when two clauses have a similar shape but should only run under different value conditions.

The beginner mindset should be: pattern first, guard second, body third. If you learn that rhythm early, you will write cleaner functions and debug them faster.

classify(N) when N < 0 -> negative;
classify(0) -> zero;
classify(N) when N > 0 -> positive.

How to read multi-clause functions

Read multi-clause functions top to bottom. Ask what the clause is trying to catch and what would fall through to the next one. Clause order matters. A broad clause placed too early can swallow cases that should have been handled later.

This makes function design feel closer to writing rules than writing instructions. You are declaring the situations in which each clause applies. That fits Erlang extremely well.

What beginners usually get wrong

A frequent mistake is putting too much logic into the function body instead of the head and guard. Another is writing guards that should really be separate clauses. Learners also forget that guards can only use a limited safe subset of expressions, which exists to keep matching predictable.

The cure is to simplify. If a clause can be explained in one sentence, it probably belongs in its own head. If a condition is just narrowing when a clause should apply, it is usually a guard.

Next step after this lesson

• Write one two-clause function for empty and non-empty input.
• Add one guard that distinguishes positive from negative values.
• Re-read the clauses top to bottom and explain why the order matters.
• Then move into recursion.

Frequently asked questions