Warning: strpos() [function.strpos]: Empty needle in /home/dealer/kasat/pkg/cahir/web/html/lib/plugins/translation2/action.php on line 53

Warning: Cannot modify header information - headers already sent by (output started at /home/dealer/kasat/pkg/cahir/web/html/lib/plugins/translation2/action.php:53) in /home/dealer/kasat/pkg/cahir/web/html/inc/actions.php on line 163
erlang:syntax [Krystian Bacławski Wiki]
 

Typy danych

Typy proste

Atomy

Specyfikacja:

  • Format: [a-z] [0-9A-Za-z@\._]* lub dowolny ciąg znaków zawarty w apostrofach.
  • Nazwane wartości.
  • Atomy reprezentujące wartości logiczne: true i false.
  • Nie podlegają odśmiecaniu!

Przykłady:

1> foo_bar.
foo_bar
2> host@example.com.
host@example.com
3> 'a# b c\n d'.
'a# b c\n d'
4> is_atom(false).
true
5> is_atom(666).
false

Wartości całkowitoliczbowe

Specyfikacja:

  • Format: FIXME
  • Dowolne liczby całkowitoliczbowe o precyzji ograniczonej pamięcią operacyjną.
  • W zależności od wartości przechowywane wewnętrznie w innej postaci.
  • Mała liczba przechowywana w słowie maszyny.
  • Duża liczba przechowywana w reprezentacji bignum.

Przykłady:

1> -123.
-123
2> 2#10001.
17
3> -16#C0DE.
-49374
4> 36#erlang.
892869676
5> is_integer(10).
true
6> is_integer('abcd').
false

Wartości zmiennopozycyjne

Specyfikacja:

  • Format: (+|-)? [0-9]+ \. [0-9]+ (E (+|-)? [0-9]+)?
  • Liczby podwójnej precyzji w formacie IEEE 754.

Przykłady:

1> 12.345.
12.345
2> -60.789.
-60.789
3> 1.234E-5.
1.234e-5
4> is_float(10).
false
5> is_float(3.14).
true

Operatory arytmetyczne

Specyfikacja:

  • Dzielenie zawsze zwraca Float.
  • Jeśli oba argumenty Integer wynikiem jest Integer.
  • div i rem biorą tylko Integer.
  • Zasada zachowania dokładności.

Operatory:

+ dodawanie
- odejmowanie
* mnożenie
/ dzielenie
div dzielenie całowitoliczbowe
rem reszta z dzielenia

Przykłady:

1> 17 div 4.
4
2> 17 rem 4.
1
3> (13 + 5) / 3.
6
4> 4.0 rem 3.
** exception: bad argument in an arithmetic expression
5> 1/2 + (2/3 + (3/4 + (4/5))) - 1.
1.71667

Operatory bitowe

Specyfikacja:

  • Można stosować wyłącznie do wartości całkowitoliczbowych i ciągów binarnych. (ale o tym kiedy indziej)

Operatory:

band koniunkcja na bitach
bor alternatywa na bitach
bxor różnica symetryczna na bitach
bnot negacja bitów
bsl przesunięcie bitowe w lewo
bsr przesunięcie bitowe w prawo

Przykłady:

1> 9 band 2#10001.
1
2> 9 bor 17.
25
3> 9 bxor 17.
24
4> bnot 9.
-10
5> 2#110 bsr 1.
3
6> 6 bsl 4.
96

Wbudowane operacje na liczbach

  • abs/1 - wartość absolutna liczby.
  • min/2 - minimum z dwóch wartości.
  • max/2 - maksimum z dwóch wartości.
  • is_number/1 - sprawdzenie czy podana wartość to liczba.

Przykłady:

1> abs( -5.0 ).
5.0
2> erlang:min( 3.0, 4 ).
3.0
3> erlang:max( 3.0, 4 ).
4
4> is_number( 10 ).
true
5> is_number( 10.0 ).
true
6> is_number( true ).
false

Wartości i operatory logiczne

Specyfikacja:

  • Wartości logiczne reprezentowane przez atomy true i false.
  • Wersje gorliwe obliczają zawsze.
  • Leniwe tak długo jak wynik jest nieznany.

Operatory:

and koniunkcja gorliwa
andalso koniunkcja leniwa
or alternatywa gorliwa
orelse alternatywa leniwa
xor różnica symetryczna
not negacja

Przykłady:

1> 1 == 2.
false
2> z > a.
true.
3> is_boolean(false).
true
4> is_boolean(2).
false
5> not( (1<3) and (2==2) ).
false
6> not( (a<z) xor (3==3) ).
true

Referencje

Specyfikacja:

  • Unikalne identyfikatory w obrębie maszyny wirtualnej Erlanga.
  • Prawie unikalne – dokładnie 2^{82} różnych wartości.
  • Użyteczne przy nadawaniu zdarzeniom identyfikatorów.

Przykłady:

1> Ref = erlang:make_ref().
#Ref<0.0.0.340>
2> is_reference( Ref ).
true.
3> ref_to_list( Ref ).
"#Ref<0.0.0.340>"

Typy złożone

Krotki

Składnia:

  • Dowolny ciąg wartości zawarty w nawiasach wąsatych.
  • Używa się do tworzenia rekordów – nazwanych krotek.
  • Można zwracać z funkcji wiele wartości upakowane do jednej krotki.
  • Szybki dostęp do elementów. {\tiny( Jak w tablicy o ustalonym rozmiarze. )}

Przykłady:

1> { a, 2.0, b, c, 1 }.
{a,2.0,b,c,1}
2> { A, B } = { 1, 2 }.
ok
3> A.
1
4> B.
2
5> {{name, "Nullislaw"}, {surname, "Gwiazdowski"}, {nickname, "SIGSEGV"}}.
{{name,"Nullislaw"},{surname,"Gwiazdowski"},{nickname,"SIGSEGV"}}

Wbudowane operacje na krotkach

  • element/2 - wyjmowanie i-tego elementu.
  • setelement/3 - zastępowanie i-tego elementu.
  • tuple_size/1 - ilość elementów w krotce.
  • is_tuple/1 - sprawdzenie czy wartość jest krotką.
  • make_tuple/3 - tworzy n-krotkę z podanymi wartościami.

Przykłady:

1> element( 2, { a, b, c } ).
b
2> setelement( 2, { a, b, c }, d ).
{a,d,c}
3> tuple_size( { a, b, c, d } ).
4
4> is_tuple( { a, 1 } ).
true
5> erlang:append_element( {a,b}, c ).
{a,b,c}
6> erlang:make_tuple( 4, 0, [{1,a},{3,c}] ).
{a,0,c,0}

Listy

Składnia:

  • Dowolny ciąg wartości zawarty w nawiasach kwadratowych.
  • Składa się z głowy i ogona, albo jest pusta.
  • Usuwanie wiąże od prawej!
  • Konkatenacja jest wolna.

Operatory:

+ + konkatenacja
– – usuwanie
| dołączanie elementu

Przykłady:

1> [ 1, b, "foobar" ].
[1,b,"foobar"]
2> [ a, b, c ] ++ [ d, e ].
[a,b,c,d,e]
3> [ a, a, b, b, c, c ] -- [ b, c ].
[a,a,b,c]
4> ([ 1, 2, 3 ] -- [ 1, 3 ]) -- [ 1, 2 ].
[]
5> [ Head | Tail ] = [ a, b, c ].
[a,b,c]
6> Head.
a
7> Tail.
[b,c]

Wbudowane operacje na listach

BIFs:

  • hd/1 - głowa listy.
  • tl/1 - ogon listy.
  • length/1 - długość listy.
  • is_list/1 - sprawdza czy wartość jest listą.

Przykłady:

1> List = [ a, b, c ].
[a,b,c].
2> hd( List ).
a
3> tl( List ).
[b,c]
4> length( List ).
3
5> is_list( List ).
true
6> is_list( 10 ).
false

Typy znakowe

Znaki

Specyfikacja:

  • Dowolne znaki UTF-8.
  • Przechowywane jako liczby całkowitoliczbowe.
  • Uwaga! Jeden znak zajmuje w reprezentacji wewnętrznej od 8 do 16 bajtów.

Przykłady:

1> $a.
97
2> $0.
48
3> $\n.
10
4> is_integer($g).
true

Ciągi znakowe

Specyfikacja:

  • Tak na prawdę listy znaków.
  • Nieefektywna postać przechowywania!

Przykłady:

1> "Hello world!"
"Hello world!"
2> [ ''H, $e, $l, $l, ''o ].
"Hello"
3> [72, 101, 108, 108, 111].
"Hello"
4> is_list( "Hello world!" ).
true

Typy binarne

Ciągi binarne

Specyfikacja:

  • Służą do efektywnego przechowywania dużej ilości danych.
  • Dużo efektywniejsze niż lista, ale mniej elastyczne przy dostępie.
  • Zapisywane jako wartości bajtów oddzielone przecinkiem, otoczone podwójnymi nawiasami kątowymi.

Przykłady:

1> is_binary(<<1,2,3,4>>).
true
2> {B1, B2} = split_binary(<<1,2,3,4,5>>, 3).
{<<1,2,3>>,<<4,5>>}
3> B3 = list_to_binary( [B2, B1] ).
<<4,5,1,2,3>>
4> size( B3 ).
5
5> <<1,A,B>> = B1.
<<1,2,3>>
6> A.
2

Ciągi bitowe

Specyfikacja:

  • Rozszerzenie ciągów binarnych. Zamiast bajtów dowolne typy.
  • Podobne do mechanizmu pack / unpack z języków skryptowych.
  • Każdy element ciągu jest w jednej z postaci:
  • Value
  • Value:Size
  • Value/Type
  • Value:Size/Type

Specyfikacja typu:

  • typ:
    • integer,
    • float,
    • binary,
    • bytes,
    • bitstring,
    • bits,
    • utf8,
    • utf16,
    • utf32.
  • znak:
    • signed,
    • unsigned.
  • jednostka - w formacie unit:Val. Rozmiar całego pola jest liczony w jednostkach. Domyślnie dla bitów i ciągów bitów jednostka ma rozmiar jednego bitu, dla binary i bajtów ma ośmiu bitów.

Przykłady ciągów bitowych

Przykłady wartości:

1> <<5:4, 5:4>>.
<<"U">>
2> "\x55".
"U"
3> <<5:2,5:8>>.
<<65,1:2>>
4> {R,G,B} = {2,61,20}.
{2,61,20}
5> <<R:5, G:6, B:5>>.
<<23,180>>

Dopasowanie wzorca:

1> <<R1:5, G1:6, B1:5>> = << 23, 180 >>.
<<23,180>>
2> {R1,G1,B1}.
{2,61,20}
3> <<D:16,E,F/binary>> = << 1, 17, 42:16 >>.
<<1,17,0,42>>
4> [D,E,F].
[273,0,<<"*">>]

Wyrażenia

Podstawy

Zmienne

Specyfikacja:

  • Format: _? [A-Z] [0-9A-Za-z_]*
  • Pojedyncze przypisanie. Wartość stała.
  • Jak działa przypisanie? Unifikacja termów!
  • Zaczyna się z twardą spacją? Wildcard! Użyteczne do ignorowania.
  • W powłoce można anulować związanie zmiennej z wartością.

Przykłady:

1> X.
* 1: variable 'X' is unbound
2> X = 5.
5
3> X * X.
25
4> X = 6.
** exception: no match of right hand side value 6
5> f(X).
ok
6> X = 6.
6

Porównywanie wyrażeń

Specyfikacja:

  • Identyczność i różnica – podobieństwo typów.
  • Porządek na typach: number < atom < reference < fun < port < pid < tuple < list < binary .
  • Porządek na listach – leksykograficzny.
  • Porządek na krotkach – liczba elementów, potem elementy.

Operatory:

== równość
/= nierówność
=:= identyczność
=/= różnica
=< mniejszy lub równy
< mniejszy
>= większy lub równy
> większy

Przykłady:

1> 1 < false.
true
3> 1.0 == 1.
true
4> 1.0 =:= 1.
false
5> { a, d } < { a, b, c }.
true
6> [ a, d ] < [ a, b, c ].
false

Dopasowanie wyrażeń

Specyfikacja:

  • Operator przypisania tak na prawdę operatorem dopasowania!
  • Po prawej wyrażenie do obliczenia.
  • Po lewej wyrażenie do którego przyrównamy obliczoną wartość.
  • Działa tak samo (na pewno?) jak unifikacja termów!

Przykłady:

1> Tuple = { a, b, c }.
{a,b,c}
2> { _, Second, _ } = Tuple.
{a,b,c}
3> Second.
b
4> { a, b } = Tuple.
** exception: no match of right hand side value {a,b,c}
5> { A, A, _ } = Tuple.
** exception: no match of right hand side value {a,b,c}

Wyrażenia blokowe

Specyfikacja:

  • Blok kodu kończący się kropką.
  • Podwyrażenia oddzielone przecinkiem.
  • Wyrażenie blokowe ma wartość!
  • Wartość jest równa wartości ostatniego podwyrażenia.
  • Używane do konstrukcji bardziej skomplikowanych funkcji.

Przykłady:

1> begin
1> a<b,
1> 3+5,
1> end.
8
2> 3+5,
2> a<b.
true

Wyrażenia sterujące

Wyrażenie warunkowe

if
  Guard1 ->
    Body1;
  ...;
  GuardN ->
    BodyN
end

Opis:

  • Przeglądanie warunków od góry do dołu.
  • Pierwszy, który zostanie spełniony, przerywa przeglądanie.
  • Jeśli żaden z warunków nie jest spełniony, zostaje rzucony wyjątek.
  • Wyrażenie if ma wartość! Konkretnie wartość obliczoną przez kod obsługujący dany warunek BodyI.

Przykład

compare(X,Y) ->
  if
    X < Y -> smaller;
    X > Y -> greater;
    true -> equal
  end.
 
parity(X) ->
  if
    X rem 2 == 1 -> odd;
    X rem 2 == 0 -> even
  end.
 
factorial(N) ->
  if
    N == 0 -> 1;
    N > 0 -> N * factorial(N - 1)
  end.

Wyrażenie dopasowania

case Expr of
  Pattern1 [when Guard1] ->
    Body1;
  ...;
  PatternN [when GuardN] ->
    BodyN
end

Opis:

  • Wzorzec Expr jest dopasowywany do kolejnych wzorców.
  • Strażnicy są opcjonalni.
  • Pierwszy, który wzorzec, który się dopasuje, przerywa przeglądanie.
  • Jeśli żaden z warunków nie jest spełniony, zostaje rzucony wyjątek.
  • Wyrażenie case też ma wartość! Konkretnie wartość obliczoną przez kod obsługujący dane dopasowanie BodyI.

Przykład

listlen(L) ->
  case L of
    [] -> 0;
[_|T] -> 1 + listlen(T)
  end.
 
index(X,Y) ->
  case X of
    0 ->
      case Y of
        [Z|_] -> Z
      end;
    N when N > 0 ->
      case Y of
        [_|Zs] -> index(N-1, Zs)
      end
    end.

Konwersje typów

Dla wartości liczbowych

  • list_to_float/1 - ciąg znaków ⇒ wartość zmiennopozycyjna.
  • list_to_integer/1 - ciąg znaków ⇒ wartość całkowitoliczbowa.
  • float_to_list/1 - wartość zmiennopozycyjna ⇒ ciąg znaków.
  • integer_to_list/1 - wartość całkowitoliczbowa ⇒ ciąg znaków.
  • trunc/1 - zaokrąglenie w dół do wartości całkowitoliczbowej.
  • round/1 - zaokrąglenie do najbliższej wartości całkowitoliczbowej.
  • float/1 - dowolna wartość liczbowa ⇒ wartość zmiennopozycyjna.

Przykłady:

1> list_to_float("1.234e5").
1.234e5
2> list_to_integer("1.234e5").
** exception: bad argument
3> integer_to_list(1234).
"1234"
4> trunc(5.5).
5
6> float(10).
10.0

Dla atomów i krotek

  • atom_to_list/1 - atom ⇒ lista.
  • list_to_atom/1 - lista ⇒ atom (potencjalnie nowy).
  • list_to_existing_atom/1 - lista ⇒ istniejący atom (w p.w. wyjątek badarg).
  • tuple_to_list/1 - krotka ⇒ lista.
  • list_to_tuple/1 - lista ⇒ krotka.

Przykłady:

1> atom_to_list(true).
"true"
2> list_to_atom("dwa").
dwa
3> list_to_existing_atom("trzy").
** exception: bad argument
4> tuple_to_list( { a, b, c } ).
[ a, b, c ]
5> list_to_tuple( [ a, b, c ] ).
{ a, b, c }

Dla ciągów binarnych

  • term_to_binary/1 - uproszczone wyrażenie ⇒ ciąg binarny.
  • binary_to_term/1 - ciąg binarny ⇒ uproszczone wyrażenie.
  • binary_to_list/1 - ciąg binarny ⇒ lista.
  • list_to_binary/1 - lista ⇒ ciąg binarny.

Przykłady:

1> Bin = term_to_binary([1,{2,a}]).
<<131,108,0,0,0,2,97,1,104,2,97,2,100,0,1,97,106>>
2> binary_to_term( Bin ).
[1,{2,a}]
3> List = binary_to_list( <<1,2,3>> ).
[1,2,3]
4> list_to_binary( List ).

Konstruktory list

[ Expr || Qualifier1, ..., QualifierN ]
  • Generator dostarcza listę wszystkich elementów, które będą rozpatrywane.
  • Predykat powoduje odsianie wygenerowanych elementów, które nie spełniają narzuconych więzów.

Przykłady:

map(F,Xs)    -> [ F(X) || X <- Xs ].
filter(P,Xs) -> [ X || X <-Xs, P(X) ].
append(Xss)  -> [ X || Xs <- Xss, X <- Xs ].

Złożone generatory

 1: pythag(N) ->
 2:   [ {A,B,C} ||
 3:     A <- lists:seq(1,N),
 4:     B <- lists:seq(1,N),
 5:     C <- lists:seq(1,N),
 6:     A+B+C =< N,
 7:     A*A+B*B =:= C*C
 8:   ].
 9:
10: 1> lib_misc:pythag(16).
11: [{3,4,5},{4,3,5}]
12: 2> lib_misc:pythag(30).
13: [{3,4,5},{4,3,5},{5,12,13},{6,8,10},{8,6,10},{12,5,13}]
perms([]) -> [[]];
perms(L) -> [[H|T] || H <- L, T <- perms(L--[H])].
 
1> lib_misc:perms("123").
["123","132","213","231","312","321"]
2> lib_misc:perms("cats").
["cats", "cast", "ctas", "ctsa", "csat", "csta", "acts", "acst",
"atcs", "atsc", "asct", "astc", "tcas", "tcsa", "tacs", "tasc",
"tsca", "tsac", "scat", "scta", "sact", "satc", "stca", "stac"]
 
erlang/syntax.txt · Last modified: 2010/05/25 19:40 by Krystian Bacławski
 
Except where otherwise noted, content on this wiki is licensed under the following license:CC Attribution-Noncommercial-No Derivative Works 3.0 Unported
Recent changes RSS feed Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki