Erlang Language Samouczek
Rozpoczęcie pracy z językiem Erlang

Uwagi

Wersje

Witaj świecie

Podczas pisania aplikacji „hello world” w Erlang musisz wiedzieć dwie rzeczy:

1. Kod źródłowy jest napisany w języku programowania erlang przy użyciu wybranego edytora tekstu
2. Aplikacja jest następnie uruchamiana na maszynie wirtualnej erlang . W tym przykładzie będziemy wchodzić w interakcje z maszyną erlang VM poprzez powłokę erlang.

Najpierw kod źródłowy aplikacji:

Utwórz nowy plik hello.erl zawierający następujące elementy:

-module(hello).
-export([hello_world/0]).

hello_world() ->
  io:format("Hello, World!~n", []).

Rzućmy okiem na to, co to oznacza:

• -module(hello). Wszystkie funkcje erlang istnieją w module . Moduły są następnie wykorzystywane do tworzenia aplikacji, które są zbiorem modułów. Ten pierwszy wiersz służy do identyfikacji tego modułu, a mianowicie witaj . Moduły można porównać do pakietów Java
• -export([hello_world/0]). Informuje kompilator, który działa, aby „publiczne” (w porównaniu do języków oo), a arity odpowiedniej funkcji. Arity to liczba argumentów pobieranych przez funkcję. Ponieważ w erlang funkcja z 1 argumentem jest postrzegana jako inna funkcja niż funkcja z 2 argumentami, chociaż nazwa może być dokładnie taka sama. To znaczy, hello_world/0 to zupełnie inna funkcja niż na przykład hello_world/1 .
• hello_world() To jest nazwa funkcji. -> wskazuje przejście do implementacji (treści) funkcji. Można to odczytać jako „hello_world () jest zdefiniowany jako ...”. Zauważ, że hello_world() (bez argumentów) jest identyfikowany przez hello_world/0 na maszynie wirtualnej, a hello_world(Some_Arg) jako hello_world/1 .
• io:format("Hello, World!~n", []) Z modułu io wywoływana jest funkcja format/2 , która jest funkcją standardowego wyjścia. ~n to specyfikator formatu, który oznacza wydrukowanie nowego wiersza. [] To lista zmiennych do wydrukowania wskazanych przez specyfikatory formatu w ciągu wyjściowym, co w tym przypadku jest niczym.
• Wszystkie instrukcje erlang muszą kończyć się na . (kropka).

W Erlang zwracany jest wynik ostatniej instrukcji w funkcji.

Teraz uruchommy naszą aplikację:

Uruchom powłokę erlang z tego samego katalogu, co plik hello.erl :

$ erl

Powinieneś otrzymać monit, który wygląda mniej więcej tak (Twoja wersja może być inna):

Eshell V8.0  (abort with ^G)
1>

Teraz wprowadź następujące polecenia:

1> c(hello).
{ok,hello}
2> hello:hello_world().
Hello, World!
ok

Przejrzyjmy kolejno każdą linię:

• c(hello) - to polecenie wywołuje funkcję c na atomie hello . To skutecznie każe hello.erl znaleźć plik hello.erl , skompilować go w module (plik o nazwie hello.beam zostanie wygenerowany w katalogu) i załadować go do środowiska.
• {ok, hello} - wynika to z wywołania funkcji c powyżej. To krotka zawierająca atom ok i atom hello . Funkcje Erlang zwykle zwracają albo {ok, Something} albo {error, Reason} .
• hello:hello_world() - wywołuje funkcję hello_world() z modułu hello .
• Hello, World! - tak drukuje nasza funkcja.
• ok - to właśnie zwróciła nasza funkcja. Ponieważ Erlang jest funkcjonalnym językiem programowania, każda funkcja coś zwraca. W naszym przypadku, mimo że nic nie hello_world() w hello_world() , ostatnim wywołaniem tej funkcji było io:format(...) i ta funkcja zwróciła się ok , co z kolei zwróciło naszą funkcję.

Moduły

Moduł erlang to plik z kilkoma zgrupowanymi funkcjami. Ten plik zwykle ma rozszerzenie .erl .

Moduł „Hello World” o nazwie hello.erl pokazano poniżej

-module(hello).
-export([hello_world/0]).

hello_world() ->
  io:format("Hello, World!~n", []).

W pliku wymagane jest zadeklarowanie nazwy modułu. Jak pokazano wcześniej w wierszu 1. Nazwa modułu i nazwa pliku przed rozszerzeniem .erl muszą być takie same.

Funkcjonować

Funkcja to zestaw instrukcji, które są zgrupowane razem. Te zgrupowane instrukcje razem wykonują określone zadanie. W erlang wszystkie funkcje zwracają wartość, gdy zostaną wywołane.

Poniżej znajduje się przykład funkcji, która dodaje dwie liczby

add(X, Y)-> X + Y.

Ta funkcja wykonuje operację dodawania z wartościami X i Y i zwraca wynik. Funkcji można użyć jak poniżej

add(2,5).

Deklaracje funkcji mogą składać się z wielu klauzul oddzielonych średnikiem. Argumenty w każdej z tych klauzul są oceniane przez dopasowanie wzorca. Następująca funkcja zwróci „krotkę”, jeśli Argument jest krotką w formularzu: {test, X}, gdzie X może mieć dowolną wartość. Zwróci „listę”, jeśli Argument jest listą o długości 2 w postaci [„test”, X], i zwróci „{błąd,„ Przyczyna ”}” w każdym innym przypadku:

function({test, X}) -> tuple;
function(["test", X]) -> list;
function(_) -> {error, "Reason"}.

Jeśli argument nie jest krotką, druga klauzula zostanie oceniona. Jeśli argument nie jest listą, zostanie oceniona trzecia klauzula.

Deklaracje funkcji mogą składać się z tak zwanych „Strażników” lub „Sekwencji Strażników”. Te Strażniki są wyrażeniami, które ograniczają ocenę funkcji. Funkcja ze Strażnikami jest wykonywana tylko wtedy, gdy wszystkie Wyrażenia Strażników dają prawdziwą wartość. Wielu Strażników można oddzielić średnikiem.

function_name(Argument) when Guard1; Guard2; ... GuardN -> (...).

Funkcja „nazwa_funkcji” będzie oceniana tylko wtedy, gdy Sekwencja wartownika jest prawdziwa. Funkcja podążania zwróci true tylko wtedy, gdy argument X będzie w odpowiednim zakresie (0..15):

in_range(X) when X>=0; X<16 -> true;
in_range(_) -> false.

Zrozumienie listy

Zrozumienia listy są konstrukcją składniową do tworzenia listy na podstawie istniejących list.
W języku erlang rozumienie listy ma postać [Expr || Qualifier1, ..., QualifierN] .
Gdzie kwalifikatory są albo generatorami Pattern <- ListExpr lub filtrują jak integer(X) oceniając na true lub false .

Poniższy przykład pokazuje zrozumienie listy z jednym generatorem i dwoma filtrami.

[X || X <- [1,2,a,3,4,b,5,6], integer(X), X > 3].

Wynikiem jest lista zawierająca tylko liczby całkowite większe niż 3.

[4,5,6]

Uruchamianie i zatrzymywanie powłoki Erlang

Uruchamianie powłoki Erlang

W systemie UNIX uruchamiasz powłokę Erlang z wiersza polecenia za pomocą polecenia erl

Przykład:

$ erl
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> 

Tekst, który pojawia się po uruchomieniu powłoki, zawiera informacje o używanej wersji Erlanga, a także inne przydatne informacje o systemie Erlang.

Aby uruchomić powłokę w systemie Windows, kliknij ikonę Erlang w menu Start systemu Windows.

Zatrzymywanie powłoki Erlanga

Aby uzyskać kontrolowane wyjście z powłoki Erlang, wpisz:

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> q().

Możesz także wyjść z powłoki Erlang, naciskając Ctrl + C w systemach UNIX lub Ctrl + Break w systemie Windows, co powoduje wyświetlenie następującego monitu:

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> 
BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded
       (v)ersion (k)ill (D)b-tables (d)istribution

Jeśli następnie naciśniesz (aby przerwać), wyjdziesz bezpośrednio z powłoki.

Inne sposoby wyjścia z powłoki erlang to: init:stop() który robi to samo co q() lub erlang:halt() .

Dopasowywanie wzorów

Jedną z najczęstszych operacji w erlang jest dopasowanie wzorca. Służy do przypisywania wartości zmiennej, w deklaracjach funkcji oraz w strukturach sterowania przepływem, takich jak instrukcje case i receive . Operacja dopasowania wzorca wymaga co najmniej 2 części: wzorca i terminu, względem którego dopasowany jest wzorek.

Przypisanie zmiennej w erlang wygląda następująco:

X = 2.

W większości języków programowania semantyka tej operacji jest prosta: powiąż wartość ( 2 ) z wybraną nazwą (zmienną - w tym przypadku X ). Erlang ma nieco inne podejście: dopasuj wzór po lewej stronie ( X ) do terminu po prawej stronie ( 2 ). W tym przypadku efekt jest taki sam: zmienna X jest teraz powiązana z wartością 2 . Jednak dzięki dopasowaniu wzorca możesz wykonywać bardziej uporządkowane przypisania.

{Type, Meta, Doc} = {document, {author, "Alice"}, {text, "Lorem Ipsum"}}.

Ta operacja dopasowywania jest wykonywana przez analizę struktury terminu z prawej strony i zastosowanie wszystkich zmiennych z lewej strony do odpowiednich wartości tego terminu, tak aby lewa strona była równa prawej stronie. W tym przykładzie Type jest powiązany z terminem: document , Meta do {author, "Alice"} i Doc do {text, "Lorem Ipsum"} . W tym konkretnym przykładzie zakłada się, że zmienne: Type , Meta i Doc są niezwiązane , dzięki czemu można używać każdej zmiennej.

Można również budować dopasowania wzorców, używając zmiennych powiązanych.

Identifier = error.

Zmienna Identifier jest teraz powiązana z error wartości. Następująca operacja dopasowania wzorca działa, ponieważ struktura jest dopasowana, a powiązany Identifier zmiennej ma taką samą wartość jak odpowiednia część terminu z prawej strony.

{Identifier, Reason} = {error, "Database connection timed out."}.

Operacja dopasowania wzorca kończy się niepowodzeniem, gdy występuje niezgodność między terminem po prawej stronie a wzorcem po lewej stronie. Następujące dopasowanie zakończy się niepowodzeniem, ponieważ Identifier jest powiązany z error wartości, który nie ma odpowiedniego wyrażenia po prawej stronie.

{Identifier, Reason} = {fail, "Database connection timed out."}.
> ** exception error: no match of right hand side value {fail,"Database ..."}