Erlang Language
Tipi di dati

Osservazioni

Numeri

In Erlang, i numeri sono interi o galleggianti. Erlang usa la precisione arbitraria per i numeri interi (bignum), quindi i loro valori sono limitati solo dalla dimensione della memoria del tuo sistema.

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

I numeri possono essere utilizzati in varie basi:

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

La notazione $ -prefix restituisce il valore intero di qualsiasi carattere ASCII / Unicode:

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

atomi

Un atomo è un oggetto con un nome identificato solo dal nome stesso.

Gli atomi sono definiti in Erlang usando letterali atomici che sono entrambi

• una stringa non quotata che inizia con una lettera minuscola e contiene solo lettere, cifre, caratteri di sottolineatura o il carattere @ , oppure
• Una singola stringa quotata

Esempi

1> hello.
hello

2> hello_world.
hello_world

3> world_Hello@.
world_Hello@

4> '1234'.     
'1234'

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

Atomi che sono usati nella maggior parte dei programmi di Erlang

Ci sono alcuni atomi che appaiono in quasi tutti i programmi di Erlang, in particolare a causa del loro uso nella libreria standard.

• true e false sono gli abituati a denotare i rispettivi valori booleani
• ok è usato solitamente come valore di ritorno di una funzione chiamata solo per il suo effetto, o come parte di un valore di ritorno, in entrambi i casi per indicare un'esecuzione corretta
• Allo stesso modo error è usato per indicare una condizione di errore che non garantisce un ritorno anticipato alle funzioni superiori
• undefined viene in genere utilizzato come segnaposto per un valore non specificato

Usa come tag

ok e error sono abbastanza spesso usati come parte di una tupla, in cui il primo elemento della tupla segnala il successo mentre altri elementi contengono il valore di ritorno effettivo o la condizione di errore:

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

{ok, _} = func(SomeValue).

Conservazione

Una cosa da tenere a mente quando si usano gli atomi è che sono memorizzati nella loro tabella globale nella memoria e questa tabella non è raccolta, quindi creare dinamicamente gli atomi, in particolare quando un utente può influenzare il nome dell'atomo, è fortemente scoraggiato.

Binari e Bitstring

Un binario è una sequenza di byte a 8 bit senza segno.

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

Un bitstring è un binario generalizzato la cui lunghezza in bit non è necessariamente un multiplo di 8.

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

Le tuple

Una tupla è una sequenza ordinata di lunghezza fissa di altri termini di Erlang. Ogni elemento nella tupla può essere qualsiasi tipo di termine (qualsiasi tipo di dati).

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]}}

elenchi

Una lista in Erlang è una sequenza di zero o più termini di Erlang, implementata come una lista concatenata. Ogni elemento nell'elenco può essere qualsiasi tipo di termine (qualsiasi tipo di dati).

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

La testa della lista è il primo elemento della lista.

La coda della lista è il resto della lista (senza la testa). È anche una lista.
Puoi usare hd/1 e tl/1 o confrontare con [H|T] per ottenere la testa e la coda dell'elenco.

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]

Prependendo un elemento a un elenco

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

Elenchi concatenanti

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

stringhe

In Erlang, le stringhe non sono un tipo di dati separato: sono solo elenchi di numeri interi che rappresentano punti di codice ASCII o Unicode:

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

Quando la shell di Erlang stamperà una lista, cercherà di indovinare se si intende effettivamente che si tratti di una stringa. Puoi disattivare questo comportamento chiamando shell:strings(false) :

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

Nell'esempio sopra, il numero intero 8 viene interpretato come il carattere di controllo ASCII per il backspace, che la shell considera un carattere "valido" in una stringa.

Identificatori di processi (Pid)

Ogni processo in erlang ha un identificatore di processo ( Pid ) in questo formato <xxx> , x è un numero naturale. Di seguito è riportato un esempio di Pid

<0.1252.0>

Pid può essere usato per inviare messaggi al processo usando 'bang' ( ! ), Anche Pid può essere limitato a una variabile, entrambi sono mostrati sotto

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

Ulteriori informazioni sulla creazione di processi e più in generale sui processi in erlang

funs

Erlang è un linguaggio di programmazione funzionale. Una delle caratteristiche di un linguaggio di programmazione delle funzioni è la gestione delle funzioni come dati (oggetti funzionali).

• Passa una funzione come argomento a un'altra funzione.
• Funzione di ritorno come risultato di una funzione.
• Mantieni le funzioni in alcune strutture dati.

In Erlang quelle funzioni sono chiamate funs. I divertimenti sono funzioni anonime.

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

I divertimenti possono anche avere diverse clausole.

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

Puoi anche usare le funzioni del modulo come dei fun Module:Function/Arity con la sintassi: fun Module:Function/Arity .
Ad esempio, lasciamo la funzione max dal modulo lists , che ha arity 1.

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

Mappe

Una mappa è un array o dizionario associativo composto da coppie (chiave, valore).

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

Per aggiornare una mappa:

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

Aggiorna solo alcune chiavi esistenti:

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

Pattern matching:

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

Bit Sintassi: valori predefiniti

Chiarimento di Erlang doc su Bit Sintassi:

4.4 Predefiniti

[Inizio omesso: << 3.14 >> non è nemmeno una sintassi legale.]

La dimensione predefinita dipende dal tipo. Per numero intero è 8. Per float è 64. Per binario è la dimensione effettiva del binario specificato:

    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

Nell'abbinamento, un segmento binario senza dimensione è consentito solo alla fine del pattern e la dimensione predefinita è il resto del file binario sul lato destro della corrispondenza:

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

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

27> X. 
97

28> Rest. 
<<"bc">>

Tutti gli altri segmenti con tipo binario in un modello devono specificare una dimensione:

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