Erlang provides a number of data types which are listed in this chapter. A piece of data of any data type is called a term.
There are two types of numeric literals, integers and floats. Besides the conventional notation, there are two Erlang-specific notations:
$
char
char
.
base
#
value
base
, which must be an
integer in the range 2..36.Examples:
1> 42. 42 2> $A. 65 3> $\n. 10 4> 2#101. 5 5> 16#1f. 31 6> 2.3. 2.30000 7> 2.3e3. 2300.00 8> 2.3e-3. 2.30000e-3
An atom is a literal, a constant with name. An atom should be enclosed in single quotes (') if it does not begin with a lower-case letter or if it contains other characters than alphanumeric characters, underscore (_), or @.
Examples:
hello phone_number 'Monday' 'phone number'
A binary is used to store an area of untyped memory.
Binaries are expressed using the bit syntax.
Examples:
1> <<10,20>>. <<10,20>> 2> <<"ABC">>. <<65,66,67>>
More examples can be found in Programming Examples.
A reference is a term which is unique in an Erlang runtime
system, created by calling make_ref/0
.
A fun is a functional object. Funs make it possible to create an anonymous function and pass the function itself -- not its name -- as argument to other functions.
Example:
1> Fun1 = fun (X) -> X+1 end. #Fun<erl_eval.6.39074546> 2> Fun1(2). 3
Read more about funs in Fun Expressions. More examples can be found in Programming Examples.
A port identifier identifies an Erlang port. open_port/2
,
which is used to create ports, will return a value of this type.
Read more about ports in Ports and Port Drivers.
A process identifier, pid, identifies a process.
spawn/1,2,3,4
, spawn_link/1,2,3,4
and
spawn_opt/4
, which are used to create processes, return
values of this type. Example:
1> spawn(m, f, []). <0.51.0>
The BIF self()
returns the pid of the calling process.
Example:
-module(m). -export([loop/0]). loop() -> receive who_are_you -> io:format("I am ~p~n", [self()]), loop() end. 1> P = spawn(m, loop, []). <0.58.0> 2> P ! who_are_you. I am <0.58.0> who_are_you
Read more about processes in Processes.
Compound data type with a fixed number of terms:
{Term1,...,TermN}
Each term Term
in the tuple is called an
element. The number of elements is said to be
the size of the tuple.
There exists a number of BIFs to manipulate tuples.
Examples:
1> P = {adam,24,{july,29}}. {adam,24,{july,29}} 2> element(1,P). adam 3> element(3,P). {july,29} 4> P2 = setelement(2,P,25). {adam,25,{july,29}} 5> size(P). 3 6> size({}). 0
Compound data type with a variable number of terms.
[Term1,...,TermN]
Each term Term
in the list is called an
element. The number of elements is said to be
the length of the list.
Formally, a list is either the empty list []
or
consists of a head (first element) and a tail
(remainder of the list) which is also a list. The latter can
be expressed as [H|T]
. The notation
[Term1,...,TermN]
above is actually shorthand for
the list [Term1|[...|[TermN|[]]]]
.
Example:
[]
is a list, thus
[c|[]]
is a list, thus
[b|[c|[]]]
is a list, thus
[a|[b|[c|[]]]]
is a list, or in short [a,b,c]
.
A list where the tail is a list is sometimes called a proper
list. It is allowed to have a list where the tail is not a
list, for example [a|b]
. However, this type of list is of
little practical use.
Examples:
1> L1 = [a,2,{c,4}]. [a,2,{c,4}] 2> [H|T] = L1. [a,2,{c,4}] 3> H. a 4> T. [2,{c,4}] 5> L2 = [d|T]. [d,2,{c,4}] 6> length(L1). 3 7> length([]). 0
A collection of list processing functions can be found in
the STDLIB module lists
.
Strings are enclosed in double quotes ("), but is not a
data type in Erlang. Instead a string "hello"
is
shorthand for the list [$h,$e,$l,$l,$o]
, that is
[104,101,108,108,111]
.
Two adjacent string literals are concatenated into one. This is done at compile-time and does not incur any runtime overhead. Example:
"string" "42"
is equivalent to
"string42"
A record is a data structure for storing a fixed number of
elements. It has named fields and is similar to a struct in C.
However, record is not a true data type. Instead record
expressions are translated to tuple expressions during
compilation. Therefore, record expressions are not understood by
the shell unless special actions are taken. See shell(3)
for details.
Examples:
-module(person). -export([new/2]). -record(person, {name, age}). new(Name, Age) -> #person{name=Name, age=Age}. 1> person:new(ernie, 44). {person,ernie,44}
Read more about records in Records. More examples can be found in Programming Examples.
There is no Boolean data type in Erlang. Instead the atoms
true
and false
are used to denote Boolean values.
Examples:
1> 2=<3. true 2> true or false. true
Within strings and quoted atoms, the following escape sequences are recognized:
Sequence | Description |
\b | backspace |
\d | delete |
\e | escape |
\f | form feed |
\n | newline |
\r | carriage return |
\s | space |
\t | tab |
\v | vertical tab |
\XYZ, \YZ, \Z | character with octal representation XYZ, YZ or Z |
\^a...\^z \^A...\^Z |
control A to control Z |
\' | single quote |
\" | double quote |
\\ | backslash |
There are a number of BIFs for type conversions. Examples:
1> atom_to_list(hello). "hello" 2> list_to_atom("hello"). hello 3> binary_to_list(<<"hello">>). "hello" 4> binary_to_list(<<104,101,108,108,111>>). "hello" 5> list_to_binary("hello"). <<104,101,108,108,111>> 6> float_to_list(7.0). "7.00000000000000000000e+00" 7> list_to_float("7.000e+00"). 7.00000 8> integer_to_list(77). "77" 9> list_to_integer("77"). 77 10> tuple_to_list({a,b,c}). [a,b,c] 11> list_to_tuple([a,b,c]). {a,b,c} 12> term_to_binary({a,b,c}). <<131,104,3,100,0,1,97,100,0,1,98,100,0,1,99>> 13> binary_to_term(<<131,104,3,100,0,1,97,100,0,1,98,100,0,1,99>>). {a,b,c}