Understanding the Erlang Syntax

As a beginner(enthusiast) the erlang syntax could throw you away if you have not seen haskell or prolog before. In this post I would give a basic walk-through of the erlang syntax, and hopefully help you better understand the erlang syntax.

Punctuation:

-module(fact).
-export([factorial/1]).

factorial(0) -> 1;
factorial(N) when N > 0, is_integer(N) -> N * factorial(N-1);
factorial(_) -> error.

             .
                      .

                 ;
                       ,                                    ;
                     .

Erlang likes punctuation.

The .(period) is used to terminate module attributes and function declarations, therefore the period represents the end of a statement.

The ;(semicolon) acts as a clause separator, both for function clauses and expression branches.

The ,(comma) is an expression separator. If a comma follows an expression, it means there’s another expression after it in the clause.

Module Declaration:

-module(fact).

This defines the name of the module (fact), the module name should be the same as the file name minus the extension erl. If the file was name a.erl at compilation you would get an error a.beam: Module name 'fact' does not match file name 'a'

Function Exports:

-export([factorial/1]).

This specifies the list of function(s) visible outside the module, it can be thought of as a list of public functions. Erlang functions are identified by their arity(number of arguments or operands the function or operation accepts), so factorial/1 refers to the factorial function that takes one argument.

Functions:

factorial(0) -> 1;
factorial(N) when N > 0, is_integer(N) -> N * factorial(N-1);
factorial(_) -> error.

Above shows definition of the function factorial, but the question arises why 3 declarations of the same function? Let’s take a look at each line and understand what they do.

• factorial(0) -> 1; whenever the factorial function is called with argument 0 it should return 1, this feature is regarded as pattern matching
• factorial(N) when N > 0, is_integer(N) -> N * factorial(N-1); there are couple of ideas going on in this line, let’s break it into smaller chunks:
  • when N > 0, is_integer(N) is a Guard and it infers that the line should only be evaluated if N is greater than 0 and N is an integer
  • N * factorial(N-1) is Recursion
  • factorial(_) _ is a catch all pattern, this line would return error when none of the previous clauses match, if you pass a string, float or a negative integer to factorial

Thanks for reading!