Erlang Language
Типы данных

замечания

чисел

В Erlang числа являются либо целыми числами, либо поплавками. Erlang использует произвольную точность для целых чисел (bignums), поэтому их значения ограничены только объемом памяти вашей системы.

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

Числа могут использоваться в различных базах:

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

$ -prefix дает целочисленное значение любого символа ASCII / Unicode:

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

атомы

Атом - это объект с именем, который идентифицируется только самим именем.

Атомы определены в Эрланге с использованием атомных литералов, которые либо

• строка без кавычек, которая начинается с строчной буквы и содержит только буквы, цифры, символы подчеркивания или символ @ или
• Одиночная кавычка

Примеры

1> hello.
hello

2> hello_world.
hello_world

3> world_Hello@.
world_Hello@

4> '1234'.     
'1234'

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

Атомы, которые используются в большинстве программ Erlang

Есть некоторые атомы, которые появляются почти в каждой программе Erlang, в частности, из-за их использования в стандартной библиотеке.

• true и false используются для обозначения соответствующих булевых значений
• ok обычно используется как возвращаемое значение функции, которая вызывается только для ее эффекта или как часть возвращаемого значения, в обоих случаях означает успешное выполнение
• Точно так же error используется для обозначения условия ошибки, которое не гарантирует раннего возврата из верхних функций
• undefined обычно используется в качестве заполнителя для неопределенного значения

Использовать в качестве тегов

ok и error довольно часто используются как часть кортежа, в котором первый элемент кортежа сигнализирует об успешности, в то время как другие элементы содержат фактическое возвращаемое значение или условие ошибки:

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

{ok, _} = func(SomeValue).

Место хранения

Одна вещь, которую следует иметь в виду при использовании атомов, состоит в том, что они хранятся в их собственной глобальной таблице в памяти, и эта таблица не собирает мусор, поэтому динамическое создание атомов, особенно когда пользователь может влиять на имя атома, в значительной степени обескураживается.

Бинарные и бинты

Двоичная последовательность представляет собой последовательность беззнаковых 8-битных байтов.

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

Битовая строка является обобщенным двоичным кодом, длина которого в битах не обязательно кратна 8.

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

Кортеж

Кортеж представляет собой упорядоченную по порядку последовательность других членов Эрланга. Каждый элемент в кортеже может быть любым типом термина (любой тип данных).

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

Списки

Список в Erlang представляет собой последовательность из нуля или более членов Erlang, реализованную как односвязный список. Каждый элемент в списке может быть любым типом термина (любой тип данных).

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

Головка списка - это первый элемент списка.

Хвост списка - это остальная часть списка (без головы). Это также список.
Вы можете использовать hd/1 и tl/1 или соответствовать [H|T] чтобы получить заголовок и хвост списка.

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]

Превращение элемента в список

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

Конкатенационные списки

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

Струны

В Erlang строки не являются отдельным типом данных: это всего лишь списки целых чисел, представляющих кодовые точки ASCII или Unicode:

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

Когда оболочка Erlang собирается распечатать список, он пытается угадать, действительно ли вы на самом деле означали, что это строка. Вы можете отключить это поведение, вызвав shell:strings(false) :

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

В приведенном выше примере целое число 8 интерпретируется как управляющий символ ASCII для backspace, который оболочка считает «допустимым» символом в строке.

Идентификаторы процессов (Pid)

Каждый процесс в erlang имеет идентификатор процесса ( Pid ) в этом формате <xxx> , x - натуральное число. Ниже приведен пример Pid

<0.1252.0>

Pid может использоваться для отправки сообщений в процесс с использованием «bang» ( ! ), Также Pid может быть ограничен переменной, оба показаны ниже

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

Подробнее о создании процессов и многом другом о процессах в erlang

Funs

Erlang - это функциональный язык программирования. Одной из особенностей языка программирования функций является обработка функций как данных (функциональных объектов).

• Передайте функцию в качестве аргумента другой функции.
• Функция возврата в результате функции.
• Удерживайте функции в некоторой структуре данных.

В Erlang эти функции называются funs. Развлечения - анонимные функции.

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

У забав также может быть несколько статей.

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

Вы также можете использовать функции модуля в качестве забавы с синтаксисом: fun Module:Function/Arity .
Например, давайте возьмем функцию max из модуля lists , у которого есть arity 1.

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

Карты

Карта представляет собой ассоциативный массив или словарь, состоящий из пар (ключ, значение).

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

Чтобы обновить карту:

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

Обновите только существующий ключ:

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

Соответствие шаблону:

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

Синтаксис бит: значения по умолчанию

Разъяснение документа Erlang о бит Синтаксис:

4.4 По умолчанию

[Начало опущено: << 3.14 >> не является даже юридическим синтаксисом.]

Размер по умолчанию зависит от типа. Для целого числа это 8. Для float это 64. Для двоичного значения это фактический размер указанного двоичного файла:

    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

При сопоставлении двоичный сегмент без размера допускается только в конце шаблона, а размер по умолчанию - это остальная часть двоичного файла в правой части совпадения:

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

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

27> X. 
97

28> Rest. 
<<"bc">>

Все остальные сегменты с двоичным типом типа в шаблоне должны указывать размер:

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