Integers
10
-234
16#AB10F
2#110111010
$A
Floats
17.368
-56.654
12.34E-10.
- B#Val is used to store numbers in base
< B >.
- $Char is used for ascii values
(example $A instead of 65).
Back to top
abcef
start_with_a_lower_case_letter
'Blanks can be quoted'
'Anything inside quotes \n\012'
- Indefinite length atoms are allowed.
- Any character code is allowed within an
atom.
Back to top
{123, bcd}
{123, def, abc}
{person, 'Joe', 'Armstrong'}
{abc, {def, 123}, jkl}
{}
- Used to store a fixed number of items.
- Tuples of any size are allowed.
Back to top
[123, xyz]
[123, def, abc]
[{person, 'Joe', 'Armstrong'},
{person, 'Robert', 'Virding'},
{person, 'Mike', 'Williams'}
]
"abcdefghi"
becomes - [97,98,99,100,101,102,103,104,105]
""
becomes - []
- Used to store a variable number of items.
- Lists are dynamically sized.
- "..." is short for the list of integers
representing the ascii character codes of the
enclosed within the quotes.
Back to top
Abc
A_long_variable_name
AnObjectOrientatedVariableName
- Start with an Upper Case Letter.
- No "funny characters".
- Variables are used to store values of data
structures.
- Variables can only be bound once! The
value of a variable can never be changed
once it has been set (bound).
Back to top
[{{person,'Joe', 'Armstrong'},
{telephoneNumber, [3,5,9,7]},
{shoeSize, 42},
{pets, [{cat, tubby},{cat, tiger}]},
{children,[{thomas, 5},{claire,1}]}},
{{person,'Mike','Williams'},
{shoeSize,41},
{likes,[boats, beer]},
...
- Arbitrary complex structures can be cre-
ated.
- Data structures are created by writing
them down (no explicit memory alloca-
tion or deallocation is needed etc.).
- Data structures may contain bound vari-
ables.
Back to top
A = 10
Succeeds - binds A to 10
{B, C, D} = {10, foo, bar}
Succeeds - binds B to 10, C to foo and D
to bar
{A, A, B} = {abc, abc, foo}
Succeeds - binds A to abc, B to foo
{A, A, B} = {abc, def, 123}
Fails
[A,B,C] = [1,2,3]
Succeeds - binds A to 1, B to 2, C to 3
[A,B,C,D] = [1,2,3]
Fails
Back to top
Pattern Matching (Cont)
[A,B|C] = [1,2,3,4,5,6,7]
Succeeds - binds A = 1, B = 2,
C = [3,4,5,6,7]
[H|T] = [1,2,3,4]
Succeeds - binds H = 1, T = [2,3,4]
[H|T] = [abc]
Succeeds - binds H = abc, T = []
[H|T] = []
Fails
{A,_, [B|_],{B}} = {abc,23,[22,x],{22}}
Succeeds - binds A = abc, B = 22
- Note the use of "_", the anonymous (don't
care) variable.
Back to top
module:func(Arg1, Arg2, ... Argn)
func(Arg1, Arg2, .. Argn)
- Arg1 .. Argn are any Erlang data struc-
tures.
- The function and module names (func
and module in the above) must be atoms.
- A function can have zero arguments.
(e.g. date() - returns the current date).
- Functions are defined within Modules.
- Functions must be exported before they
can be called from outside the module
where they are defined.
Back to top
-module(demo).
-export([double/1]).
double(X) ->
times(X, 2).
times(X, N) ->
X * N.
- double can be called from outside the
module, times is local to the module.
- double/1 means the function double
with one argument (Note that double/1
and double/2 are two different functions).
Back to top
unix> erl
Eshell V2.0
1> c(demo).
double/1 times/2 module_info/0
compilation_succeeded
2> demo:double(25).
50
3> demo:times(4,3).
** undefined function:demo:times[4,3] **
** exited: {undef,{demo,times,[4,3]}} **
4> 10 + 25.
35
5>
- c(File) compiles the file File.erl.
- 1> , 2> ... are the shell prompts.
- The shell sits in a read-eval-print loop.
Back to top
date()
time()
length([1,2,3,4,5])
size({a,b,c})
atom_to_list(an_atom)
list_to_tuple([1,2,3,4])
integer_to_list(2234)
tuple_to_list({})
- Are in the module erlang.
- Do what you cannot do (or is difficult to
do) in Erlang.
- Modify the behaviour of the system.
- Described in the BIFs manual.
Back to top
Is defined as a collection of clauses.
func(Pattern1, Pattern2, ...) ->
... ;
func(Pattern1, Pattern2, ...) ->
... ;
...
func(Pattern1, Pattern2, ...) ->
... .
Evaluation Rules
- Clauses are scanned sequentially until a match is found.
- When a match is found all variables occurring in the head
become bound.
- Variables are local to each clause, and
are allocated and deallocated automatically.
- The body is evaluated sequentially.
Back to top
Functions (cont)
-module(mathStuff).
-export([factorial/1, area/1]).
factorial(0) -> 1;
factorial(N) -> N * factorial(N-1).
area({square, Side}) ->
Side * Side;
area({circle, Radius}) ->
% almost :-)
3 * Radius * Radius;
area({triangle, A, B, C}) ->
S = (A + B + C)/2,
math:sqrt(S*(S-A)*(S-B)*(S-C));
area(Other) ->
{invalid_object, Other}.
Back to top
factorial(0) -> 1;
factorial(N) ->
N * factorial(N-1)
> factorial(3)
matches N = 3 in clause 2
== 3 * factorial(3 - 1)
== 3 * factorial(2)
matches N =2 in clause 2
== 3 * 2 * factorial(2 - 1)
== 3 * 2 * factorial(1)
matches N = 1 in clause 2
== 3 * 2 * 1 * factorial(1 - 1)
== 3 * 2 * 1 �* factorial(0)
== 3 * 2 * 1 �* 1 (clause 1)
== 6
- Variables are local to each clause.
- Variables are allocated and deallocated
automatically.
Back to top
factorial(0) -> 1;
factorial(N) when N > 0 ->
N * factorial(N - 1).
- The reserved word when introduces a
guard.
- Fully guarded clauses can be re-ordered.
factorial(N) when N > 0 ->
N * factorial(N - 1);
factorial(0) -> 1.
factorial(N) ->
N * factorial(N - 1);
factorial(0) -> 1.
Back to top
number(X) - X is a number
integer(X) - X is an integer
float(X) - X is a float
atom(X) - X is an atom
tuple(X) - X is a tuple
list(X) - X is a list
length(X) == 3 - X is a list of length 3
size(X) == 2 - X is a tuple of size 2.
X > Y + Z - X is > Y + Z
X == Y - X is equal to Y
X =:= Y - X is exactly equal to Y
(i.e. 1 == 1.0 succeeds but
1 =:= 1.0 fails)
- All variables in a guard must be bound.
- See the User Guide for a full list of
guards and allowed function calls.
Back to top
average(X) -> sum(X) / len(X).
sum([H|T]) -> H + sum(T);
sum([]) -> 0.
len([_|T]) -> 1 + len(T);
len([]) -> 0.
- Note the pattern of recursion is the same
in both cases. This pattern is very common.
Two other common patterns:
double([H|T]) -> [2*H|double(T)];
double([]) -> [].
member(H, [H|_]) -> true;
member(H, [_|T]) -> member(H, T);
member(_, []) -> false.
Back to top
average(X) -> average(X, 0, 0).
average([H|T], Length, Sum) ->
average(T, Length + 1, Sum + H);
average([], Length, Sum) ->
Sum / Length.
- Only traverses the list ONCE
- Executes in constant space (tail recursive)
- The variables Length and Sum play the
role of accumulators
- N.B. average([]) is not defined - (you cannot
have the average of zero elements) -
evaluating average([]) would cause a run-time error
- we discuss what happens when run time
errors occur in the section on
error handling .
Back to top
h() - history . Print the last 20 commands.
b() - bindings. See all variable bindings.
f() - forget. Forget all variable bindings.
f(Var) - forget. Forget the binding of variable
X. This can ONLY be used as a command to
the shell - NOT in the body of a function!
e(n) - evaluate. Evaluate the n:th command
in history.
e(-1) - Evaluate the previous command.
- Edit the command line as in Emacs
- See the User Guide for more details and
examples of use of the shell.
Back to top
apply(Mod, Func, Args)
- Apply the function Func in the module Mod
to the arguments in the list Args.
-
Mod and Func must be atoms (or
expressions which evaluate to atoms).
1> apply( lists1,min_max,[[4,1,7,3,9,10]]).
{1, 10}
- Any Erlang expression can be used in
the arguments to apply.
Back to top
case lists:member(a, X) of
true ->
... ;
false ->
...
end,
...
if
integer(X) -> ... ;
tuple(X) -> ...
end,
...
- Not really needed - but useful.
Back to top