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:
Examples:
1> 42. 42 2> $A. 65 3> $\n. 10 4> 2#101. 5 5> 16#1f. 31 6> 2.3. 2.3 7> 2.3e3. 2.3e3 8> 2.3e-3. 0.0023
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 bit string is used to store an area of untyped memory.
Bit Strings are expressed using the
Bit Strings which consists of a number of bits which is evenly divisible by eight are called Binaries
Examples:
1> <<10,20>>. <<10,20>> 2> <<"ABC">>. <<"ABC">> 1> <<1:1,0:1>>. <<2:2>>
More examples can be found in Programming Examples.
A reference is a term which is unique in an Erlang runtime
system, created by calling
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
A port identifier identifies an Erlang port.
Read more about ports in
A process identifier, pid, identifies a process.
1> spawn(m, f, []). <0.51.0>
The BIF
-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
Compound data type with a fixed number of terms:
{Term1,...,TermN}
Each term
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> tuple_size(P). 3 6> tuple_size({}). 0
Compound data type with a variable number of key-value associations:
#{Key1=>Value1,...,KeyN=>ValueN}
Each key-value association in the map is called an association pair. The key and value parts of the pair are called elements. The number of association pairs is said to be the size of the map.
There exists a number of BIFs to manipulate maps.
Examples:
1> M1 = #{name=>adam,age=>24,date=>{july,29}}. #{age => 24,date => {july,29},name => adam} 2> maps:get(name,M1). adam 3> maps:get(date,M1). {july,29} 4> M2 = maps:update(age,25,M1). #{age => 25,date => {july,29},name => adam} 5> map_size(M). 3 6> map_size(#{}). 0
A collection of maps processing functions can be found in
the STDLIB module
Read more about
Maps are considered experimental during OTP 17.
Compound data type with a variable number of terms.
[Term1,...,TermN]
Each term
Formally, a list is either the empty list
Example:
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
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
Strings are enclosed in double quotes ("), but is not a
data type in Erlang. Instead a string
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
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
There is no Boolean data type in Erlang. Instead the atoms
Examples:
1> 2 =< 3. true 2> true or false. true
Within strings and quoted atoms, the following escape sequences are recognized:
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.0 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} 14> binary_to_integer(<<"77">>). 77 15> integer_to_binary(77). <<"77">> 16> float_to_binary(7.0). <<"7.00000000000000000000e+00">> 17> binary_to_float(<<"7.000e+00>>"). 7.0