Erlang Language
Gegevenstypen

Opmerkingen

Numbers

In Erlang zijn getallen gehele getallen of drijvers. Erlang gebruikt willekeurige precisie voor gehele getallen (bignums), dus hun waarden worden alleen beperkt door de geheugengrootte van uw systeem.

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

Nummers kunnen op verschillende basissen worden gebruikt:

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

$ -prefix notatie levert de gehele waarde van elk ASCII / Unicode-teken op:

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

atomen

Een atoom is een object met een naam die alleen wordt geïdentificeerd door de naam zelf.

Atomen worden gedefinieerd in Erlang met behulp van atoomliteralen die dat ook zijn

• een niet-genoteerde tekenreeks die begint met een kleine letter en alleen letters, cijfers, onderstrepingstekens of het @ -teken bevat, of
• Een enkele aanhalingsteken

Voorbeelden

1> hello.
hello

2> hello_world.
hello_world

3> world_Hello@.
world_Hello@

4> '1234'.     
'1234'

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

Atomen die in de meeste Erlang-programma's worden gebruikt

Er zijn enkele atomen die in bijna elk Erlang-programma voorkomen, met name vanwege hun gebruik in de standaardbibliotheek.

• true en false worden gebruikt om de respectieve Booleaanse waarden aan te duiden
• ok wordt meestal gebruikt als een retourwaarde van een functie die alleen wordt aangeroepen voor het effect, of als onderdeel van een retourwaarde, in beide gevallen om een succesvolle uitvoering aan te duiden
• Op dezelfde manier wordt error gebruikt om een foutconditie aan te duiden die geen vroege terugkeer van de bovenste functies rechtvaardigt
• undefined wordt meestal gebruikt als tijdelijke aanduiding voor een niet-gespecificeerde waarde

Gebruik als tags

ok en error worden vaak gebruikt als onderdeel van een tuple, waarin het eerste element van de tuple succes aangeeft, terwijl andere elementen de werkelijke retourwaarde of foutconditie bevatten:

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

{ok, _} = func(SomeValue).

opslagruimte

Een ding om in gedachten te houden bij het gebruik van atomen is dat ze worden opgeslagen in hun eigen globale tabel in het geheugen en deze tabel is geen afval verzameld, dus dynamisch atomen maken, met name wanneer een gebruiker de atoomnaam kan beïnvloeden, wordt sterk afgeraden.

Binaries en bitstrings

Een binair getal is een reeks niet-ondertekende 8-bits bytes.

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

Een bitstring is een gegeneraliseerde binary waarvan de lengte in bits niet noodzakelijk een veelvoud van 8 is.

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

tuples

Een tupel is een geordende reeks van andere Erlang-termen met een vaste lengte. Elk element in de tuple kan elk type term (elk gegevenstype) zijn.

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

lijsten

Een lijst in Erlang is een reeks van nul of meer Erlang-termen, geïmplementeerd als een afzonderlijk gekoppelde lijst. Elk element in de lijst kan elk type term (elk gegevenstype) zijn.

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

Het hoofd van de lijst is het eerste element van de lijst.

De staart van de lijst is de rest van de lijst (zonder het hoofd). Het is ook een lijst.
Je kunt hd/1 en tl/1 of vergelijken met [H|T] om de kop en staart van de lijst te krijgen.

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]

Een element voorbereiden op een lijst

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

Lijsten samenvoegen

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

strings

In Erlang zijn tekenreeksen geen afzonderlijk gegevenstype: het zijn slechts lijsten met gehele getallen die ASCII- of Unicode-codepunten vertegenwoordigen:

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

Wanneer de Erlang-shell een lijst gaat afdrukken, probeert deze te raden of u het echt als een string bedoelde. U kunt dat gedrag uitschakelen door shell:strings(false) aan te roepen:

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

In het bovenstaande voorbeeld wordt het gehele getal 8 geïnterpreteerd als het ASCII-besturingsteken voor backspace, wat de shell als een "geldig" karakter in een string beschouwt.

Processen Identifiers (Pid)

Elk proces in erlang heeft een proces-ID ( Pid ) in dit formaat <xxx> , waarbij x een natuurlijk getal is. Hieronder is een voorbeeld van een Pid

<0.1252.0>

Pid kan worden gebruikt om berichten naar het proces te verzenden met behulp van 'bang' ( ! ), Ook Pid kan worden beperkt tot een variabele, beide worden hieronder weergegeven

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

Lees meer over het maken van processen en meer in het algemeen over processen in erlang

funs

Erlang is een functionele programmeertaal. Een van de functies in een programmeertaal voor functies is het verwerken van functies als gegevens (functionele objecten).

• Geef een functie als argument door aan een andere functie.
• Retourneer functie als gevolg van een functie.
• Hold-functies in een bepaalde gegevensstructuur.

In Erlang worden die functies funs genoemd. Funs zijn anonieme functies.

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

Funs kunnen ook verschillende clausules bevatten.

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

U kunt ook fun Module:Function/Arity gebruiken als funs met de syntaxis: fun Module:Function/Arity .
Laten we bijvoorbeeld de functie max van lists , die arity 1 heeft.

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

Kaarten

Een kaart is een associatieve array of woordenboek dat bestaat uit (sleutel, waarde) paren.

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

Een kaart bijwerken:

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

Werk alleen een bestaande sleutel bij:

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

Patroon matching:

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

Bitsyntaxis: standaardwaarden

Verduidelijking van Erlang-doc op bitsyntaxis:

4.4 Standaardwaarden

[Begin weggelaten: << 3.14 >> is zelfs geen juridische syntaxis.]

De standaardgrootte is afhankelijk van het type. Voor geheel getal is het 8. Voor float is het 64. Voor binair getal is dit de werkelijke grootte van het opgegeven binair getal:

    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

Bij het matchen is een binair segment zonder Grootte alleen toegestaan aan het einde van het patroon, en de standaard Grootte is de rest van het binaire getal aan de rechterkant van de wedstrijd:

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

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

27> X. 
97

28> Rest. 
<<"bc">>

Alle andere segmenten met type binair in een patroon moeten een grootte opgeven:

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