2 Data Types
2.1 Terms
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.
2.2 Number
There are two types of numeric literals, integers and floats. Besides the conventional notation, there are two Erlang-specific notations:
$
char
ASCII value of the characterchar
.
base
#
value
Integer with the basebase
, which must be an integer in the range 2..32.
In Erlang 5.2/OTP R9B and earlier versions, the allowed range is 2..16.
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-32.3 Atom
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'2.4 Binary
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.
2.5 Reference
A reference is a term which is unique in an Erlang runtime system, created by calling
make_ref/0
.2.6 Fun
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). 3Read more about funs in Fun Expressions. More examples can be found in Programming Examples.
2.7 Port Identifier
A port identifier identifies an Erlang port.
open_port/2
, which is used to create ports, will return a value of this type.Read about Erlang ports in the Interoperability Tutorial and in the documentation of
open_port/2
inerlang(3)
.2.8 Pid
A process identifier, pid, identifies a process.
spawn/1,2,3,4
,spawn_link/1,2,3,4
andspawn_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_youRead more about processes in Processes.
2.9 Tuple
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({}). 02.10 List
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([]). 0A collection of list processing functions can be found in the STDLIB module
lists
.2.11 String
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"2.12 Record
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.
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.
2.13 Boolean
There is no Boolean data type in Erlang. Instead the atoms
true
andfalse
are used to denote Boolean values.Examples:
1> 2=<3. true 2> true or false. true2.14 Escape Sequences
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...\^Zcontrol A to control Z \' single quote \" double quote \\ backslash Recognized Escape Sequences. 2.15 Type Conversions
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}