Erlang Language
Tipos de datos

Observaciones

Números

En Erlang, los números son enteros o flotantes. Erlang utiliza precisión arbitraria para enteros (bignums), por lo que sus valores están limitados solo por el tamaño de la memoria de su sistema.

1> 11.
11
2> -44.
-44
3> 0.1.
0.1
4> 5.1e-3.
0.0051
5> 5.2e2.
520.0

Los números se pueden utilizar en varias bases:

1> 2#101.
5
2> 16#ffff.
65535

La notación de $ prefijo proporciona el valor entero de cualquier carácter ASCII / Unicode:

3> $a.
97
4> $A.
65
5> $2.
50
6> $🤖.
129302

Los átomos

Un átomo es un objeto con un nombre que se identifica solo por el nombre mismo.

Los átomos se definen en Erlang usando literales atómicos que son

• una cadena sin comillas que comienza con una letra minúscula y solo contiene letras, dígitos, guiones bajos o el carácter @ , o
• Una sola cadena entre comillas

Ejemplos

1> hello.
hello

2> hello_world.
hello_world

3> world_Hello@.
world_Hello@

4> '1234'.     
'1234'

5> '!@#$%% ä'.
'!@#$%% ä'

Átomos que se utilizan en la mayoría de los programas de Erlang

Hay algunos átomos que aparecen en casi todos los programas de Erlang, en particular debido a su uso en la Biblioteca Estándar.

• true y false son los utilizados para denotar los valores booleanos respectivos
• ok se usa generalmente como un valor de retorno de una función que se llama solo por su efecto, o como parte de un valor de retorno, en ambos casos para significar una ejecución exitosa
• De la misma manera, el error se utiliza para indicar una condición de error que no garantiza un retorno anticipado de las funciones superiores
• undefined se usa generalmente como un marcador de posición para un valor no especificado

Utilizar como etiquetas

ok y error se usan con frecuencia como parte de una tupla, en la que el primer elemento de la tupla indica el éxito, mientras que otros elementos contienen el valor de retorno real o la condición de error:

func(Input) ->
    case Input of
        magic_value ->
            {ok, got_it};
        _ ->
            {error, wrong_one}
    end.

{ok, _} = func(SomeValue).

Almacenamiento

Una cosa que se debe tener en cuenta cuando se usan átomos es que se almacenan en su propia tabla global en la memoria y que esta tabla no se recolecta, por lo que se crean átomos dinámicamente, en particular cuando un usuario puede influir en el nombre del átomo.

Binarios y cadenas de bits

Un binario es una secuencia de bytes de 8 bits sin firmar.

1> <<1,2,3,255>>.
<<1,2,3,255>>
2> <<256,257,258>>.
<<0,1,2>>
3> <<"hello","world">>.
<<"helloworld">>

Una cadena de bits es un binario generalizado cuya longitud en bits no es necesariamente un múltiplo de 8.

1> <<1:1, 0:2, 1:1>>.
<<9:4>> % 4 bits bitstring

Tuplas

Una tupla es una secuencia ordenada de longitud fija de otros términos de Erlang. Cada elemento de la tupla puede ser cualquier tipo de término (cualquier tipo de datos).

1> {1, 2, 3}.
{1,2,3}
2> {one, two, three}.
{one,two,three}
3> {mix, atom, 123, {<<1,2>>, [list]}}.
{mix,atom,123,{<<1,2>>,[list]}}

Liza

Una lista en Erlang es una secuencia de cero o más términos de Erlang, implementada como una lista enlazada individualmente. Cada elemento de la lista puede ser cualquier tipo de término (cualquier tipo de datos).

1> [1,2,3].
[1,2,3]
2> [wow,1,{a,b}].     
[wow,1,{a,b}]

La cabeza de la lista es el primer elemento de la lista.

La cola de la lista es el resto de la lista (sin la cabeza). También es una lista.
Puede usar hd/1 y tl/1 o comparar [H|T] para obtener la cabecera y la cola de la lista.

3> hd([1,2,3]).
1
4> tl([1,2,3]).
[2,3]
5> [H|T] = [1,2,3].
[1,2,3]
6> H.
1
7> T.
[2,3]

Anteponer un elemento a una lista

8> [new | [1,2,3]].
[new,1,2,3]

Listas de concatenacion

9> [concat,this] ++ [to,this].
[concat,this,to,this]

Instrumentos de cuerda

En Erlang, las cadenas no son un tipo de datos separado: son solo listas de enteros que representan puntos de código ASCII o Unicode:

> [97,98,99].
"abc"
> [97,98,99] =:= "abc".
true
> hd("ABC").
65

Cuando el shell de Erlang va a imprimir una lista, intenta adivinar si realmente querías que fuera una cadena. Puedes desactivar ese comportamiento llamando a shell:strings(false) :

> [8].
"\b"
> shell:strings(false).
true
> [8].
[8]

En el ejemplo anterior, el entero 8 se interpreta como el carácter de control ASCII para el retroceso, que el shell considera un carácter "válido" en una cadena.

Identificadores de Procesos (Pid)

Cada proceso en erlang tiene un identificador de proceso ( Pid ) en este formato <xxx> , siendo x un número natural. A continuación se muestra un ejemplo de un Pid

<0.1252.0>

Pid se puede usar para enviar mensajes al proceso usando 'bang' ( ! ), También Pid se puede enlazar a una variable, ambas se muestran a continuación

MyProcessId = self().
MyProcessId ! {"Say Hello"}.

Lea más sobre la creación de procesos y más en general sobre los procesos en erlang

Diversión

Erlang es un lenguaje de programación funcional. Una de las características de un lenguaje de programación de funciones es manejar las funciones como datos (objetos funcionales).

• Pasa una función como argumento a otra función.
• Función de retorno como resultado de una función.
• Mantener funciones en alguna estructura de datos.

En Erlang esas funciones se llaman funs. Las diversiones son funciones anónimas.

1> Fun = fun(X) -> X*X end.
#Fun<erl_eval.6.52032458>
2> Fun(5).
25

Las diversiones también pueden tener varias cláusulas.

3> AddOrMult = fun(add,X) -> X+X;
3>                (mul,X) -> X*X 
3> end.
#Fun<erl_eval.12.52032458>
4> AddOrMult(mul,5).
25
5> AddOrMult(add,5).
10

También puede usar las funciones del módulo como fun Module:Function/Arity con la sintaxis: fun Module:Function/Arity .
Por ejemplo, tomemos la función max del módulo de lists , que tiene arity 1.

6> Max = fun lists:max/1.
#Fun<lists.max.1>
7> Max([1,3,5,9,2]). 
9

Mapas

Un mapa es una matriz asociativa o diccionario compuesto de pares (clave, valor).

1> M0 = #{}.
#{}
2> M1 = #{ "name" => "john", "age" => "28" }.
#{"age" => "28","name" => "john"}
3> M2 = #{ a => {M0, M1} }.
#{a => {#{},#{"age" => "28","name" => "john"}}}

Para actualizar un mapa:

1> M = #{ 1 => x }.
2> M#{ 1 => c }.
#{1 => c}
3> M.
#{1 => x}

Solo actualice alguna clave existente:

1> M = #{ 1 => a, 2 => b}.
2> M#{ 1 := c, 2:= d }.
#{1 => c,2 => d}
3> M#{ 3 := c }.
** exception error: {badkey,3}

La coincidencia de patrones:

1> M = #{ name => "john", age => 28 }.
2> #{ name := Name, age := Age } = M.
3> Name.
"john"
4> Age.
28

Sintaxis de bits: valores predeterminados

Aclaración de Erlang doc en Bit Sintaxis:

4.4 Valores predeterminados

[Principio omitido: << 3.14 >> ni siquiera es una sintaxis legal.]

El tamaño predeterminado depende del tipo. Para entero es 8. Para float es 64. Para binario es el tamaño real del binario especificado:

    1> Bin = << 17/integer, 3.2/float, <<97, 98, 99>>/binary >>. 
    <<17,64,9,153,153,153,153,153,154,97,98,99>>
      ^ |<-------------------------->|<------>|
      |            float=64           binary=24
  integer=8


    2> size(Bin). % Returns the number of bytes:
    12            % 8 bits + 64 bits + 3*8 bits = 96 bits => 96/8 = 12 bytes

En la coincidencia, un segmento binario sin un Tamaño solo se permite al final del patrón, y el Tamaño predeterminado es el resto del binario en el lado derecho de la coincidencia:

25> Bin = <<97, 98, 99>>. 
<<"abc">>

26> << X/integer, Rest/binary >> = Bin. 
<<"abc">>

27> X. 
97

28> Rest. 
<<"bc">>

Todos los demás segmentos con tipo binario en un patrón deben especificar un Tamaño:

12> Bin = <<97, 98, 99, 100>>.         
<<"abcd">>

13> << B:1/binary, X/integer, Rest/binary >> = Bin. %'unit' defaults to 8 for  
<<"abcd">>                    %binary type, total segment size is Size * unit  

14> B.
<<"a">>

15> X.
98

16> Rest.
<<"cd">>

17> << B2/binary, X2/integer, Rest2/binary >> = Bin. 
* 1: a binary field without size is only allowed at the end of a binary pattern