Bevezetés

A tantárgy a deklaratív programozási nyelvekkel foglalkozik, gyakorlati megközelítésben. Két fő irányát tanuljuk:

• a funkcionális programozást az Elixir nyelven,
• a logikai programozást a Prolog nyelven.

A jegyzet első része a deklaratív szemlélet áttekintése után az Elixir nyelvet és a funkcionális programozás eszközeit tárgyalja.

Forrás: dp26a-fp1ea.pdf (3. dia)

Deklaratív programozás

Kijelentő és felszólító nyelvek

A Wikipédia meghatározása szerint a deklaratív programozás olyan programozási paradigma, amely kifejezi a számítás logikáját anélkül, hogy leírná a vezérlési folyamatát (declarative programming is a programming paradigm that expresses the logic of a computation without describing its control flow).

A „deklaratív” jelző a nyelvészetből származik: jelentése kijelentő, kinyilatkoztató, ellentmondást nem tűrő, mint a „kijelentő mondat”. A mondatfajták között van kérdő és felszólító (imperatív) is. A számítógépek belső nyelve, a gépi kód alapvetően felszólító jellegű: add hozzá, szorozd meg, ugorj. A magas szintű programozási nyelvek többsége is imperatív: while ... do ..., goto ..., értékadás (írd felül a változó értékét).

C-ben is lehet deklaratívan programozni, például ciklus helyett rekurzióval:

int fact(int n) {if (n > 0) return n * fact(n-1);
                  else return 1;
                 }

Ez a változat lassú, mert minden hívás a verembe kerül. Az ún. jobbrekurzív (farokrekurzív, tail recursive) változata azonban a ciklussal azonos hatékonyságú kóddá fordul (lásd Rekurzió).

A deklaratív szemlélet előnye, hogy a programkód sokkal közelebb áll a specifikációhoz, ezért a helyességéről sokkal könnyebb meggyőződni. A megközelítés jelmondata:

MIT és nem HOGYAN

vagy kicsit enyhítve: inkább MIT, mint HOGYAN (WHAT rather than HOW).

A deklaratív nyelvekben a változó a matematika változófogalmának felel meg: egyetlen, esetleg még ismeretlen értéket jelöl, és nem írható felül.

Funkcionális és logikai programozás

A deklaratív programozás két fő ága egy-egy alapvető matematikai fogalomhoz kapcsolódik:

• a funkcionális programozás (FP) a függvényekhez,
• a logikai programozás (LP) a relációkhoz.

graph TD
  P["Programozási paradigmák – programozási nyelvek"] --> I["Imperatív<br/><i>Fortran, Algol, C, Java, Python, ...</i>"]
  P --> D["Deklaratív"]
  D --> F["Funkcionális<br/><i>LISP, ML, Haskell, Erlang, <b>Elixir</b>, ...</i>"]
  D --> L["Logikai<br/><i>SQL, <b>Prolog</b>, Constraint Prog., ...</i>"]

A kurzus tárgya az Elixir funkcionális és a Prolog logikai programozási nyelv.

Példa: listák összefűzése Elixirben és Prologban

Az Elixir és a Prolog közös szintaxist használ a láncolt listák jelölésére:

• [] az üres lista,
• [Head|Tail] olyan lista, amelynek feje (első eleme) Head, farka (a fej utáni része) pedig a Tail lista.

Az 1, 2, 3 számokból álló lista így [1|[2|[3|[]]]], vagy tömörebben [1,2,3].

Írjunk egy app nevű kétargumentumú Elixir-függvényt (app/2), amely két listát összefűz! Két esetet kell megkülönböztetni: ha az első lista üres, az eredmény a második lista; ha nem üres, akkor a feje lesz az eredmény feje, a farka pedig a farok és a második lista összefűzöttje:

#   app(l1,   l2): l1 és l2 listák összefűzöttje (l1⊕l2)
def app([],    b) do            b end       # [] ⊕b = b
def app([x|a], b) do [x|app(a,b)] end       # [x|a] ⊕b = [x|a⊕b]

Az app függvénynek egy háromargumentumú Prolog-eljárás (másnéven predikátum) felel meg (app/3); a harmadik argumentum az Elixir-függvény eredménye:

%   app(L1, L2, L12): L1 és L2 listák összefűzöttje L12 (L1⊕L2 = L12)
    app([],    B,               B).         % [] ⊕B = B
    app([X|A], B,    [X|       C]) :-       % [X|A] ⊕B = [X|C] ha
           app(A, B, C).                    %      A ⊕B = C

Az eljáráshívások a függvényhívásokkal ellentétben nem ágyazhatók egymásba, ezért kell a C segédváltozó. De ennek köszönhetően az app/3 Prolog-eljárás jobbrekurzív, azaz ciklussá fordul.

Prologban az is megengedett, hogy egy adatstruktúrában behelyettesítetlen változó szerepeljen. Az eljárás így is írható:

app([],    B, B).
app([X|A], B, L) :- L = [X|C], app(A, B, C).

A Prolog-változó pointerként is felfogható: app először felépíti az eredménylista első láncszemét ([X|C]), majd a jobbrekurzív hívással kitölti az eredménylista C által mutatott farkát, például:

app([1], [2], L) ⇒ L = [1|C], app([], [2], C) ⇒ L = [1|[2]] = [1,2]

Az app/3 eljárás nemcsak összefűzésre használható. Mivel relációt ír le, bármelyik argumentuma lehet ismeretlen. Bal oldalt a kérdések, a ⟹ után a Prolog válaszai (a ; újabb megoldást kér, a no jelzi, hogy nincs több):

| ?- app([1,2], [3,4], L).        ⟹   L = [1,2,3,4] ? ; no
| ?- app([1,2], B, [1,2,3,4]).    ⟹   B = [3,4] ? ; no
| ?- app([1,2], B, [1,3,4,5]).    ⟹   no
| ?- app(A, B, [1,2]).            ⟹   A = [], B = [1,2] ? ;
                                       A = [1],  B = [2] ? ;
                                       A = [1,2], B = [] ? ; no

Az utolsó kérdés az [1,2] lista összes lehetséges kettévágását sorolja fel.

Forrás: dp26a-fp1ea.pdf (14–18. dia)

Az Elixir nyelv

Fő jellemzők

Az Elixir

• funkcionális nyelv;
• a nyelvben minden kifejezés: nincs utasítás (statement) és kifejezés (expression) megkülönböztetés;
• a különféle esetek felismerésére és szétválasztására mintaillesztést használ (Mintaillesztés);
• ciklusok helyett rekurziót és magasabb rendű függvényeket használ (Rekurzió, Függvény);
• dinamikusan típusos (Típusok);
• nincs semmi megosztva: a processzek üzenetekkel kommunikálnak;
• Erlang-függvények hívhatók Elixirből, Elixir-függvények Erlangból.

Erlang, BEAM és Elixir

Az Erlang Open Telecom Platform (OTP) az Ericsson által fejlesztett nyílt forráskódú rendszer masszívan párhuzamos, elosztott, megbízható alkalmazások fejlesztésére. Kihasználja az üzenetküldést és azt, hogy nincs megosztott memória és nincs változómódosítás; akár függvények is átküldhetők a szerverek között.

• Erlang: az OTP platform eredeti funkcionális programozási nyelve, a Prologhoz hasonló szintaxissal.
• BEAM: az Erlang/OTP virtuális gépe.
• Elixir: funkcionális programozási nyelv a BEAM platformra, modern (a Rubyra hasonlító) szintaxissal.

A viszonyuk olyan, mint a Java-világban: BEAM : Erlang : Elixir ≈ JVM : Java : Kotlin. A Livebook pedig az Elixir számára az, ami a Jupyter a Pythonnak: notebook.

Folyamatok üzenetekkel kommunikálnak

A folyamatok (processzek) között nincs megosztott memória; egymással üzenetküldéssel kommunikálnak (aktor modell). Az alábbi példában a spawn/1 új folyamatot indít, amely a receive blokkban üzenetre vár. A főfolyamat a send/2-vel küld neki egy üzenetet, benne a saját azonosítójával (self()) mint válaszcímmel, majd maga is a válaszra vár; a beérkező üzenetet mintaillesztéssel fogadja:

worker = spawn(fn -> # Új folyamat indítása
  receive do # Várakozás üzenetre
    {:hello, from} -> # Válasz küldése from felé
      send(from, {:reply, "Hello from the worker process!"})
  end
end)
send(worker, {:hello, self()}) # Üzenet küldése válaszcímmel
receive do # Várakozás a worker folyamat válaszára
  {:reply, message} -> # Üzenet fogadása mintaillesztéssel
    IO.puts(message)
end

Az egymás utáni üzenetekre rekurzív függvényekkel lehet válaszolni: a függvény fogad egy üzenetet, válaszol rá, majd jobbrekurzívan újra meghívja önmagát, és várja a következőt.

Forrás: dp26a-fp1ea.pdf (21., 26–27. dia)

Interaktív használat: IEx és Livebook

Az IEx

Az Elixir interaktív héja, az iex egy REPL (read-eval-print loop): beolvas egy kifejezést, kiértékeli, és kiírja az értékét. A promptban zárójelben a kifejezés sorszáma áll.

$ iex
Erlang/OTP ...
Interactive Elixir ...
  press Ctrl+C to exit
  (type h() ENTER for help)

iex> 3.2 + 2.1 * 2
7.4

iex> :atom
:atom

iex> Atom
Atom

iex> "string"
"string"

iex> {:ennes,:%,A,:':',9.8}
{:ennes, :%, A, :":", 9.8}

iex> [:lista,:%,A,:':',9.8]
[:lista, :%, A, :":", 9.8]

iex> i :':'
...Data type
    Atom...

Az i segédfüggvény információt ír ki a kapott termről, például a típusát.

Az IEx-ből a Ctrl+C lenyomásával léphetünk ki. Ekkor a BEAM megszakítási menüje jelenik meg; egy újabb Ctrl+C kilép a héjból:

iex> Ctrl+C
BREAK: (a)bort (A)bort with dump (c)ontinue
   (p)roc info (i)nfo (l)oaded (v)ersion
   (k)ill (D)b-tables (d)istribution
Ctrl+C
$

A Ctrl+G a felhasználói parancsmódot (User switch command) nyitja meg; a h kiírja a parancsait, a q kilép:

iex> Ctrl+G
User switch command
--> h
  c [nn]            - connect to job
  i [nn]            - interrupt job
  k [nn]            - kill job
  j                 - list all jobs
  s [shell]         - start local shell
  r [node [shell]]  - start remote shell
  q                 - quit erlang
  ? | h             - this message
  --> q
$

IEx-parancsok

Az IEx segédfüggvényeit (helpers) a h() listázza:

iex> h().
Welcome to Interactive Elixir.
...
c/1            - compiles a file
c/2            - compiles a file and writes bytecode to the given path
cd/1           - changes the current directory
clear/0        - clears the screen
exports/1      - shows all exports (functions + macros) in a module
h/1            - prints help for the given module, function or macro
i/0            - prints information about the last value
i/1            - prints information about the given term
ls/0           - lists the contents of the current directory
ls/1           - lists the contents of the specified directory
pwd/0          - prints the current working directory
r/1            - recompiles the given module's source file
v/0            - retrieves the last value from the history
v/1            - retrieves the nth value from the history
...
To learn more about IEx as a whole, type h(IEx).

Az IEx-ben érdemes kipróbálni a Kernel Elixir-modul és a :math Erlang-könyvtár ismert függvényeit, és figyelni a tabulátorral kérhető szövegkiegészítést (completion).

Saját program fordítása, futtatása

Függvényt csak modulban lehet definiálni. Az alábbi fpea.ex fájl az Fpea modulban definiálja a faktoriális függvényt. A fájlnév konvenció szerint csupa kisbetűs, a szavak között aláhúzással (snake_case); a modulnév egybeírt, a szavak nagy kezdőbetűvel (BumpyCase, CamelCase).

defmodule Fpea do
# Fájlnév csupa kisbetűvel, szavak között aláhúzás (snake_case)
# Modulnév egybe, szavak nagy kezdőbetűvel (BumpyCase, CamelCase)
  @spec fac(n::integer) :: f::integer # Típusspecifikáció
  # f = n! (azaz f az n faktoriálisa) # Fejkomment
  def fac(0), do: 1            # ha az n=0 mintaillesztés sikeres
  def fac(n), do: n * fac(n-1) # ha az n=0 mintaillesztés sikertelen
end

A fájlt az IEx-ben a c paranccsal fordítjuk le; a függvényt a modulnévvel minősítve hívjuk:

iex> c "fpea.ex"  # fordítás
[Fpea]

iex> Fpea.fac(5)  # futtatás
120

iex> fac(5)         # a modulnevet ki kell írni
** (CompileError) iex:3: undefined function fac/1
iex> Fpea.fac 5   # argumentum körül a zárójel sokszor elhagyható
120

Egy már betöltött modul exportált függvényeit az exports Fpea írja ki (itt fac/1), a módosított forrásfájlt pedig az r Fpea fordítja újra.

Modulok és függvények azonosítása

Az Elixirben egy függvényt három dolog azonosít: a neve, az aritása (a paramétereinek száma) és annak a modulnak a neve, amelyben definiálva van. Például a String.slice/2 és a String.slice/3 a String modul két azonos nevű függvénye: az egyiknek két, a másiknak három paramétere van. Ha ugyanabban a modulban hivatkozunk egy függvényre, amelyben definiálva van, a modulnév elmaradhat.

A def exportált (a modulon kívülről is hívható), a defp privát függvényt definiál:

defmodule Dummy do

  def dummy0, do: 2024             # exportált, paraméter nélkül

  def dummy1(p), do: dummy2(p)     # exportált fv.

  defp dummy2(p), do: IO.puts (p)  # privát fv.

end

Dummy.dummy0

Dummy.dummy0 |> IO.inspect()

Dummy.dummy1('karakterlánc')    # karakterkódokból álló lácolt lista, nem sztring!

Dummy.dummy1(~c"karakterlista") # a ~c egy ún. szigil, speciális jelölés az Elixirben

Dummy.dummy1("sztring")

# Dummy.dummy2("sztring")

Az IO.puts/1 mindhárom paramétert szövegként írja ki (karakterlánc, karakterlista, sztring). A kikommentezett Dummy.dummy2("sztring") hívás UndefinedFunctionError hibát adna, mert a privát függvény a modulon kívülről nem látszik. Modulon kívül függvény nem definiálható: a def dummy, do: "halihó" önmagában a cannot invoke def/2 outside module hibát adja.

Livebook

A Livebook az Elixir notebookja, a Python Jupyteréhez hasonló. A gyakorlatok feladatsorai Livebook-formátumban (.livemd) jelennek meg. Az IEx-szel szemben a Livebookban modul is definiálható egy cellában.

A Livebook Elixir-cellái különálló modulokként fordulnak le. Ha egy cellában egy modulnak nevet adtunk, ugyanazt a nevet egy másik cellában már nem használhatjuk: ha az azonos nevű modult tartalmazó második cellát is kiértékeljük, az Elixir hibát jelez. Ennek előnye, hogy a korábbi cellákban definiált függvényeket a modulnév megadásával a későbbi cellákból is hívhatjuk.

Kiírás: IO.inspect, inspect, IO.puts

Egy kifejezéssorozat kiértékelésekor az Elixir (a Livebook is) csak az utolsó kifejezés értékét írja ki. A korábbi kifejezések értékét az IO.inspect/1-gyel íratjuk ki:

[1|[2|[3|[]]]] |> IO.inspect()
[1,2|[3]] # |> IO.inspect()
[1,2,3]

Az alábbi cellában az első kifejezés értékével nem kezdünk semmit, ezért nem is jelenik meg sehol; csak a második, utolsó kifejezés értéke ([1, 2, 3]) látszik:

App3.app([], [])        # E kifejezés értékével nem kezdünk semmit, nem is jelenik meg sehol.
App3.app([], [1, 2, 3])

Az IO.inspect/1-gyel mindkettő kiíratható (az App3.app/2 két listát fűz össze, lásd Típusok):

IO.inspect(App3.app([], []))        # Itt sem kezdünk vele semmit, de kiírjuk a már látott
IO.inspect(App3.app([], [1, 2, 3])) #  IO.inspect/1 függvénnyel, direkt paraméterátadással.

A |> az ún. pipe operátor (mint a Linuxban a |): a bal oldalán álló kifejezés eredményét a jobb oldalán álló függvénynek adja át, mégpedig az első paramétereként, ha több paramétere is van.

Az IO.inspect/1 nemcsak kiírja a kapott kifejezés értékét, hanem eredményként változatlanul vissza is adja, ezért a többi inspect függvénnyel együtt nagyon hasznos hibakeresési eszköz: bárhová beszúrható egy kifejezésbe.

[1 |> IO.inspect(), 2 |> IO.inspect(), 3 |> IO.inspect()] |> IO.inspect()

Ez sorban kiírja az 1, 2, 3 értéket, majd az [1, 2, 3] listát.

Az IO.inspect/2 és a Kernel modulban definiált inspect/2 (a Kernel modulnév elhagyható) között az a különbség, hogy az előbbi kiírja a kapott kifejezést, és az értékét változatlan formában továbbadja, az utóbbi pedig sztringgé konvertálva adja eredményül (a Livebook ezt a sztringet a cella eredményeként jeleníti meg). Az IO.puts/1 a kapott kifejezést sztringgé alakítva írja ki, és az :ok atomot adja vissza. Az inspect függvények működése opciókkal befolyásolható; a listák kiírását szabályozó charlists: opciót a Lista és karakterlánc fejezet mutatja be.

Forrás: dp26a-fp1ea.pdf (35–37. dia), dp26a-fp1gyfel.livemd, dp26a-fp1gy-megoldasok.livemd

Projektek, mérés, típusellenőrzés: mix, benchee, dialyzer

Miért kell projektszervezés?

• Az Elixirhez sokféle modul van. A gyakran használtak (pl. Kernel, Enum, List, String) az Elixir-alapcsomag részei, a többit (pl. Benchee) utólag kell telepíteni, ha és amikor szükség van rájuk.
• Magának a fordítónak (elixir, elixirc, iex) is, a moduloknak is több verziója van, és az újabb verziók nem mindig kompatibilisek a korábbiakkal: a függőségeket kezelni kell.
• Egy saját projekt általában több modulból áll, plusz a teszteléshez használt adatokból és segédprogramokból; ezeket célszerű áttekinthetően, rendben tartani.
• Az Elixirhez kidolgozott segédeszközök csak akkor használhatók, ha betartjuk a konvenciókat, nemcsak a névadásra, hanem például a fájlokat tároló mappák szerkezetére vonatkozóakat is.

Elixir-projektek kezelésére készült a mix, amely az Elixir-csomag része (https://elixir-lang.org/getting-started/mix-otp/introduction-to-mix.html). A legfontosabb hívási formái a mix --help szerint:

mix             - Invokes the default task (mix run) in a project
mix new PATH    - Creates a new Elixir project at the given path
mix help        - Lists all available tasks
mix help TASK   - Prints documentation for a given task

Új projekt

Hozzunk létre egy fp nevű projektet egy új, ugyancsak fp nevű mappában! Az fp/lib mappában létrejön az fp.ex fájl, benne az Fp modul sablonjával; ez lenne a modul neve a --module opció nélkül is.

# mix new fp --module Fp
* creating README.md
* creating .formatter.exs
* creating .gitignore
* creating mix.exs
* creating lib
* creating lib/fp.ex
* creating test
* creating test/test_helper.exs
* creating test/fp_test.exs

Your Mix project was created successfully.
You can use "mix" to compile it, test it, and more:
    cd fp
    mix test
Run "mix help" for more commands.

# ls -F fp
lib/  mix.exs  README.md  test/

A projekt leírása a mix.exs fájlban van, és ez – mi más is lehetne – Elixir-kód:

defmodule Fp.MixProject do
  use Mix.Project
  def project do
    [
      app: :fp,
      version: "0.1.0",
      elixir: "~> 1.18",
      start_permanent: Mix.env() == :prod,
      deps: deps()
    ]
  end
  # Run "mix help compile.app" to learn about applications.
  def application do
    [
      extra_applications: [:logger]
    ]
  end

  # Run "mix help deps" to learn about dependencies.
  defp deps do
   [
    # {:dep_from_hexpm, "~> 0.3.0"},
    # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: ...}
   ]
  end
end

A mix.exs két publikus (def) és egy privát (defp) függvényt definiál. A project a projekt konfigurációjáról tárol adatokat, az application-nel egy applikációs fájlt lehet generálni; ezek részleteibe nem megyünk bele. A deps privát függvény törzsében kell leírni a függőségeket: a kívánt modulok nevét és paramétereit.

Függőség felvétele: benchee

Új függőségként a Benchee modult vesszük fel, amely – ahogy a neve is sugallja – benchmarkingra, futási idők mérésére használható (https://github.com/bencheeorg/benchee). A mix.exs vége ezzel így néz ki:

 # Run "mix help deps" to learn about dependencies.
 defp deps do
  [
   {:benchee, "~> 1.0", only: :dev},
   # {:dep_from_hexpm, "~> 0.3.0"},
   # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: ...}
  ]
 end

Ezután letöltjük és lefordítjuk az új modult és a függőségeit. Az új modulok az adott projekt részei lesznek: lokálisak, nem globálisak.

~/tmp/fp$ mix do deps.get + deps.compile
Resolving Hex dependencies...
Resolution completed in 0.051s
New:
  benchee 1.4.0
  deep_merge 1.0.0
  statistex 1.1.0
...
Compiling ...

Fordítás és futtatás mix-szel

Tegyük a lib/sum.ex fájlba egy egészlista összegét kiszámoló függvény három változatát (a különbségüket a Rekurzió fejezet tárgyalja):

defmodule Sum do
  def sum1([]), do: 0
  def sum1([x|xs]), do: x + sum1(xs)

  def sum2([x|xs]), do: x + sum2(xs)
  def sum2([]), do: 0

  def sum3(xs), do: sumi(xs, 0)

  defp sumi([x|xs], sum), do: sumi(xs, sum+x)
  defp sumi([], sum), do: sum
end

# A fájl végére írt kifejezéseket az iex automatikusan ki fogja értékelni
1..1000 |> Range.to_list() |> Sum.sum1() |> IO.inspect()
1..1000 |> Range.to_list() |> Sum.sum2() |> IO.inspect()
1..1000 |> Range.to_list() |> Sum.sum3() |> IO.inspect()

• Fordítani a mix compile-lal lehet. A lefordított fájl a _build/dev/lib/fp/ebin/ mappába kerül, a sum.ex esetében Elixir.Sum.beam néven.

• Az iex-et a mix-projekt konfigurációjával és függőségeivel így indítjuk (lásd mix help, elixir --help):

  iex -S mix # Starts IEx and runs the default task
  

• A programot az r paranccsal (pontosabban az r segédfüggvénnyel) lehet betölteni, újratölteni:

  iex> r Sum
  

• A Sum modulban definiált függvények ezután hívhatók:

  iex> Sum.sum1 [1,2,3,4,5]
  15
  

A modult záró end után álló függvényhívásokat az iex betöltéskor kiértékeli; az IO.inspect ezek eredményét ki is írja. Ha újratöltjük a programot az r segédfüggvénnyel, az eredmény megjelenik a képernyőn:

iex> r Sum
...
500500
{:reloaded, [Sum]}

Mérés és profilozás: benchee

A méréshez a Benchee.run/1 függvényt kell meghívni egy fájlban, például a benchee_sum.exs-ben. A paramétere egy szótár: a kulcsok a mérések nevei, az értékek névtelen függvények, amelyek törzsében a mérendő hívás áll.

Benchee.run(%{"sum1" => fn -> 1..10_000 |> Enum.to_list() |> Sum.sum1() end,
              ...
              }
           )

Az elemzést a mix run lib/benchee_sum.exs paranccsal indítjuk. Ha azt is tudni szeretnénk, hogy a függvényeink által meghívott függvények milyen gyakran és mennyi ideig futnak, a profile_after opciót is meg kell adni:

Benchee.run(%{"sum1" => fn -> 1..10_000 |> Enum.to_list() |> Sum.sum1() end,
              ...
             },
             profile_after: true
           )

A Benchee először kiírja a gép és a futtatás adatait (operációs rendszer, processzor, Elixir- és Erlang-verzió, a bemelegítés és a mérés ideje), majd egy táblázatot. Az ips a másodpercenkénti végrehajtások száma (iterations per second, K = ezer), az average, a median és a 99th % a futási idő átlaga, mediánja és 99. percentilise, a deviation a szórás az átlag százalékában. A Comparison rész a leggyorsabbhoz viszonyítja a többit (1.83x slower +51.30 µs). A három sum változat eredményei a Rekurzió fejezetben láthatók.

Livebookban a függőségeket a notebook első cellájában a Mix.install/1 tölti be, például Mix.install([{:benchee, "~> 1.3"}]). Livebook-cellából futtatott mérésnél a Benchee figyelmeztet, hogy a mért függvények kiértékelt (evaluated) és nem lefordított függvények, ezért lassabbak; pontosabb méréshez a hívást modulbeli függvénybe vagy mix run-nal futtatott .exs fájlba érdemes tenni.

Típusellenőrzés: dialyzer

A dialyzer az Erlang/Elixir programok statikus elemzője: a lefordított kódból kikövetkezteti a függvények típusát (success typing), és összeveti a típusspecifikációkkal (@spec, lásd Típusok). Jelzi például, ha egy specifikáció nem felel meg a függvénynek. Elixir-projektben a dialyxir modullal használjuk, amelyet a benchee-hez hasonlóan a függőségek közé kell felvenni:

 # Run "mix help deps" to learn about dependencies.
 defp deps do
  [
   {:dialyxir, "~> 1.4", only: [:dev, :test], runtime: false},
   # {:dep_from_hexpm, "~> 0.3.0"},
   # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: ...}
  ]
 end

~/tmp/fp$ mix do deps.get, deps.compile
Resolving Hex dependencies...
Resolution completed in 0.051s
New:
  dialyxir 1.4.6
  erlex 0.2.7
...
Compiling ...

A projekt forrásfájljainak a lib mappában kell lenniük. Rakjunk ide egy Elixir-programot, például az egyik kisházit, rontsunk el egy-két specifikációt, és dializáljuk!

• A dializálás a lib mappában lévő összes .ex fájlt vizsgálja.
• Az első futtatás sokáig tart, mert a dialyzer rengeteg ún. PLT-fájlt (Persistent Lookup Table) telepít a modulokhoz tartozó típusszignatúrákkal.
• A dializálás a .beam fájlokat elemzi, ezért ha valamelyik forrásfájl megváltozott, az elemzés előtt lefordítja.

Az alábbi sum/1 specifikációja szerint a függvény egészlistát adna vissza, pedig egy számot ad. A dialyzer ezt invalid_contract hibaként jelzi, és megmutatja a kikövetkeztetett típust (success typing) a specifikáció mellett:

@spec sum(xs::[integer()]) :: s::[integer()]
# Az xs számlista összege s
def sum([x|xs]), do: x + sum(xs)
def sum([]), do: 0

~/tmp/fp$ mix dialyzer
lib/sum.ex:2:invalid_contract
The @spec for the function does not match the success typing ...
Function: Sum.sum/1
Success typing: ([number()]) -> number()
But the spec is: (xs::[integer()]) -> s::[integer()]

A dialyzert Livebook-cellában nem lehet futtatni, mert a dialyzer a lefordított BEAM-kódot elemzi, a Livebook pedig nem menti el a BEAM-kódot a háttértárba. Ezért hozzunk létre egy mix-projektet, másoljuk ki az elemzendő programrészeket a Livebook-cellá(k)ból, és mentsük el a projekt lib mappájába egy .ex kiterjesztésű fájlba. Ezután, a dialyxir függőség letöltése és a modulok lefordítása után, futtatható a mix dialyzer (lásd még https://hexdocs.pm/dialyxir/readme.html). A mix parancssoros használatához az Elixirt telepíteni kell a saját gépre, vagy Dockerből kell tudni futtatni.

Forrás: dp26a-fp1ea.pdf (41–49. dia), dp26a-fp3ea.pdf (29–30. dia), dp26a-fp1ea-sum-benchee.livemd, dp26a-fp3gy.livemd, dp26a-fp2gy-megoldasok.livemd

Típusok

Az Elixir erősen típusos nyelv, dinamikus típusellenőrzéssel:

• erősen típusos: minden értéknek pontosan egy futásidejű típusa van;
• dinamikus típusellenőrzésű: a típusokat nem kötelező megadni a kódban, és egy változóhoz nem feltétlenül csak egy típus tartozik.

A fontosabb típusok (a felsorolás nem teljes; a dőlt betűs típusok más alaptípusokra épülnek):

A következő alfejezetek sorra veszik őket.

Típusspecifikáció

Bár a típusokat nem kötelező megadni, dokumentációs céllal típusspecifikáció írható a függvényekhez a @spec attribútummal. Ez javítja a függvény dokumentáltságát és ezáltal az olvashatóságát, továbbá lehetővé teszi, hogy a dialyzer segédprogrammal ellenőrizzük a függvény típushelyességét (lásd Projektek, mérés, típusellenőrzés). Két példa:

• @spec tl(xs :: [any()]) :: ts :: [any()] | nil: „A tl függvény argumentuma egy xs tetszőleges elemű lista, visszatérési értéke (ts) egy szintén tetszőleges elemű lista vagy nil.”
• @spec nth(xs :: [any()], n :: integer()) :: r :: any() | nil: „Az nth függvény argumentumai egy xs tetszőleges elemű lista és egy n egész szám, visszatérési értéke (r) vagy egy tetszőleges típusú érték vagy nil.”

A paramétereknek és az eredménynek nevet is adhatunk (xs ::, ts ::); a | két típus unióját jelöli.

A specifikáció mellé a kurzus a #-tel kezdődő deklaratív fejkommentet is elvárja. A fejkomment a bemenő paraméter(ek) és a függvény visszatérési értéke közötti kapcsolatot fejezi ki deklaratív módon, azaz lehetőleg a mi-re, és nem a hogyan-ra ad választ. A specifikációban adott nevekre hivatkozik:

defmodule App3 do
  @spec app(xs :: [integer()], ys :: [integer()]) :: zs :: [integer()]
  # xs és ys listák összefűzöttje zs
  def app([x|xs], ys), do: [x|app(xs, ys)]
  def app([], ys),     do: ys
end

Forrás: dp26a-fp2ea.pdf (4. dia), dp26a-fp1ea.pdf (25. dia), dp26a-fp1gyfel.livemd

Atom, szám, igazságérték

Atom

Az atom olyan konstans, amelynek az értéke maga a neve.

• Kettősponttal (:) kezdődik.
• Kezdődhet az angol ábécé nagybetűjével is, kettőspont nélkül, de ez konvenció szerint a modulnevekre van fenntartva.
• A : után UTF-8 kódolású karaktersorozat, Elixir-operátor vagy sztring állhat.
• Az UTF-8 kódolású karaktersorozatban betűk, számjegyek és kétféle írásjel (_, @) lehetnek; a karaktersorozat végén általában kérdőjel (?) vagy felkiáltójel (!) is állhat.
• Saját magát jelöli, nem sztring: egy atom értéke maga a neve.
• Két azonos nevű atom mindig egyenlő, akárhol is vannak definiálva.
• Hasonló a Prolog névkonstanshoz (atomhoz).

Példák: :jános, :is_bin?, :vált@2, :<>, :"fun/3", :"éljen soká!", :Éljen_soká!, :"Őrült Űrőr tűrjön", Dp, Gy1.

Szám

Egész (integer):

• decimális, pl. 1234;
• hexadecimális, pl. 0xcafe;
• oktális, pl. 0o765;
• bináris, pl. 0b1010;
• tagolható, pl. 123_456_789;
• korlátlan pontosságú, pl. 123456789012345678901234567890;
• karakterkód (Unicode codepoint): ha nyomtatható, ?z, ha vezérlő, ?\n. A ?z tehát egész szám, a z karakter kódja (122).

Lebegőpontos (float):

• pl. 3.14159;
• vezető nullával, pl. 0.14159 (a tizedespont előtt mindig kell számjegy);
• exponenssel, pl. 0.2e-22;
• IEEE 754 szerinti, dupla pontosságú (64 bit, kb. 16 számjegy, max. exponens kb. $10^{308}$).

Igazságérték

Igazságérték, másnéven logikai érték (boolean):

• Három atomot tekintünk igazságértéknek: :true, :false, :nil.
• Mindhárom írható kettőspont nélkül is: true, false, nil.
• A false és a nil hamis, minden más érték (nemcsak a true) igaz.
• Angolul szokás megkülönböztetni a true-t a truthy-tól (igaznak számító érték), a false-t a falsy-tól (hamisnak számító érték), pl. a JavaScriptben, a Javában, az Elixirben.

A logikai műveleteket a Műveletek és beépített függvények fejezet tárgyalja.

Forrás: dp26a-fp2ea.pdf (5–6., 25. dia)

Függvény

A függvény is érték

A függvény is érték: változóhoz köthető, adatstruktúra eleme lehet, függvény eredménye lehet, paraméterként átadható stb. Azaz a függvény is ún. first class citizen, teljes jogú polgár.

Egy modulban definiált függvényt a & operátorral (capture operator) tehetünk értékké: &Modul.név/aritás. Az így kapott függvényértéket ponttal és zárójelpárral hívjuk. Az infix operátorok is függvények, és prefix helyzetben is alkalmazhatók; az :math Erlang-modul függvényei ugyanígy elérhetők:

iex> fac = &Fpea.fac/1 # &: capture operator
&Fpea.fac/1

iex> fac.(5) # pont és zárójelpár kell, szóközökkel tagolható
120

iex> Kernel.+(3,2) # infix operátor alkalmazása prefix helyzetben
5

iex> fs = [&Kernel.+/2, &*/2, &:math.sin/1] # :math Erlang modul!
[&:erlang.+/2, &:erlang.*/2, &:math.sin/1]

iex> (hd fs).(3,2)
5

iex> (hd tl fs).(3,2)
6

iex> (hd tl tl fs).(:math.pi * 90 / 180)
1.0

A fs lista elemei függvények; a hd fs a lista feje (az összeadás), a hd tl fs a második eleme (a szorzás), a hd tl tl fs a harmadik (a szinusz). Az eredmény kiírásából látszik, hogy az Elixir Kernel.+/2 és */2 operátora valójában az :erlang modul függvénye.

Névtelen függvény

Névtelen (anonim) függvényt az fn paraméterek -> törzs end kifejezéssel definiálunk. Közvetlenül is meghívható, és névhez is köthető; a hívásnál itt is kell a pont:

iex> fn ki -> "Szia, " <> ki <> "!" end # <>: konkatenálás
#Function<44.40011524/1 in :erl_eval.expr/5>

iex> fn ki -> "Szia, "<>ki<>"!" end.("Péter") # pont, zárójel!
"Szia, Péter!"

iex> szia = fn ki -> "Szia, " <> ki <> "!" end
#Function<44.40011524/1 in :erl_eval.expr/5>

iex> szia
#Function<44.40011524/1 in :erl_eval.expr/5>

iex> szia.("Bea")
"Szia, Bea!"

A #Function<...> a függvényérték kiírt alakja; a számok verziónként és futásonként mások.

Függvénydefiníció modulban

Modulban a def publikus, a defp privát, azaz a modulon belül lokális függvényt definiál. A modulban definiált függvény hívásakor a pont nem kell, és az argumentumok körüli zárójel sokszor elhagyható:

def sum_of_squares(a,b), do: sqr(a) + sqr(b)
defp sqr(a), do: a*a # p[rivát], azaz lokális a modulon belül

iex> Fpea.sum_of_squares 3, 4.5
29.25

A függvény típusa: (arg1 típusa, arg2 típusa, ...) :: eredmény típusa. Például a sum_of_squares/2 függvényé: (number, number) :: number.

Paraméter alapértelmezett értéke

Egy függvény egy vagy több paraméterének a \\ jelöléssel alapértelmezett (default) értéket adhatunk. Az ilyen paraméter opcionális, a többi elvárt. Ha egy függvényt

• a kötelezően (default argumentumok nélkül) elvártnál kevesebb paraméterrel hívunk meg, a hívás meghiúsul;
• az elvárt számú paraméterrel hívunk meg, az összes opcionális paraméter az alapértelmezett értékét veszi fel;
• az elvártnál több paraméterrel hívunk meg, az aktuális paraméterek értékét balról jobbra haladva veszik fel az opcionális paraméterek.

def sum_of_sqrs_b5(a, b \\ 5), do: sqr(a) + sqr(b)

iex> Fpea.sum_of_sqrs_b5 3, 4.5
29.25

iex> Fpea.sum_of_sqrs_b5 3
34

def sum_of_sqrs_a6b5(a \\ 6, b \\ 5), do: sqr(a) + sqr(b)

iex> Fpea.sum_of_sqrs_a6b5 3
34

iex> Fpea.sum_of_sqrs_a6b5
61

A sum_of_sqrs_a6b5 3 hívásban az egyetlen aktuális paraméter az első opcionális paraméterhez, a-hoz kerül, b az alapértelmezett 5 lesz: $3^2+5^2=34$. Paraméter nélkül mindkettő az alapértelmezett: $6^2+5^2=61$.

Magasabb rendű függvények

Mivel a függvény is érték, átadható egy másik függvénynek. Azt a függvényt, amelynek paramétere vagy eredménye függvény, magasabb rendű függvénynek nevezzük. A ciklusok helyett ezekkel szétválaszthatjuk az adatszerkezet rekurzív bejárását az elemeken elvégzendő műveletektől. Az alábbi L.map/2 egy egyszeresen láncolt listát jár be, a T.map/2 egy bináris fát; mindkettő az f paraméterként kapott függvényt alkalmazza minden elemre:

defmodule L do # Egyszeresen láncolt lista bejárás
  def map([], _f), do: []
  def map([hd|tl], f), do: [f.(hd)|map(tl, f)]
end
defmodule T do # Bináris fa bejárás
  def map(nil, _f), do: nil
  def map({x, left, right}, f), do: {f.(x), map(left, f), map(right, f)}
end

A fát itt {x, left, right} hármasok ábrázolják, az üres fát a nil. Egy alkalmazás:

iex> L.map [1, 2, 3], fn(x) -> 2 * x end
[2, 4, 6]

A magasabb rendű függvények egyre gyakoribbak az objektumorientált nyelvekben is:

• Java: List.of(1, 2, 3).stream().map(x -> 2 * x).toList()
• C#: new List<int>{1, 2, 3}.Select(x => 2 * x)

Forrás: dp26a-fp2ea.pdf (7–9. dia), dp26a-fp1ea.pdf (24. dia)

Ennes és tartomány

Ennes (Tuple)

Az ennes rögzített számú, tetszőleges kifejezésből álló, fix sorrendű kollekció. Jelölése kapcsos zárójel, az elemek vesszővel elválasztva. Ennesként tudunk két vagy több értéket paraméterként átadni vagy eredményként visszakapni.

iex> {0x1ff, :erlang, Armstrong, 'Joe'++[0], [], {}}
{511, :erlang, Armstrong, [74, 111, 101, 0], [], {}}

iex> {plus, per, sin} = # mintaillesztések kötésekkel
  {&Kernel.+/2, &//2, &:math.sin/1}
{&:erlang.+/2, &:erlang.//2, &:math.sin/1}

iex> {plus.(3,4), per.(3,4)} # infix volt, prefix lett
{7, 0.75}

iex> sin.(90*:math.pi/180)
1.0

Az első példában a 0x1ff értéke 511, a 'Joe'++[0] pedig a 'Joe' karakterkód-lista és a [0] összefűzése; mivel a 0 nem nyomtatható karakter kódja, a lista számokként jelenik meg (lásd Lista és karakterlánc). A második példa mintaillesztéssel köti a három függvényt a plus, per és sin változóhoz (lásd Mintaillesztés).

Tartomány (Range)

A tartomány egész számok sorozata a [start, end] tartományban, start..end vagy lépésközzel start..end//lépés alakban:

iex> {18..23, 18..10}
{18..23, 18..10//-1}

iex> for i <- 18..10 // -3, do: i
[18, 15, 12]

A 18..10 csökkenő tartomány, az Elixir ki is írja a -1 lépésközt. A második példa a for-jelöléssel sorolja fel a 18..10//-3 tartomány elemeit.

Forrás: dp26a-fp2ea.pdf (10. dia)

Lista és karakterlánc

Lista (List)

A lista korlátlan számú, tetszőleges kifejezésből álló, egyszeresen láncolt sorozat, a deklaratív nyelvek talán legalapvetőbb adatstruktúrája. Lineáris rekurzív adatstruktúra:

• vagy üres (jele []),
• vagy egy elemből áll, amelyet egy lista követ: [x|xs].

A lista első eleme, ha van, a lista feje; az első eleme utáni, esetleg üres része a lista farka. Mivel a lista láncolt, csak az első elemét érjük el közvetlenül; az utolsó és bármely közbülső elemét csak úgy, ha előbb az összes előtte álló elemet eltávolítjuk.

Ugyanaz a lista többféleképpen is leírható; a tömörebb változatok könnyebben írhatók és olvashatók. Az 1, 2, 3 egészekből álló lista például [1|[2|[3|[]]]], [1,2|[3]] vagy [1,2,3]. A | előtt több elem is állhat, vesszővel elválasztva:

iex> [:elem] # egyelemű lista
[:elem]

iex> [:elem|[]] # fejből és üres farokból létrehozott lista
[:elem]

iex> [:elem1|[:elem2]] # fejből-farokból létrehozott lista
[:elem1, :elem2]

iex> [:elem,123,3.14,'elem'] # több elemű listák
[:elem, 123, 3.14, ~c"elem"]

iex> [:elem,123|[3.14,'elem']]
[:elem, 123, 3.14, ~c"elem"]

iex> [:egy|[:két]] ++ [:elem,123|[3.14,'elem']] # ++: konkatenáció
[:egy, :két, :elem, 123, 3.14, ~c"elem"]

A listaműveleteket a Műveletek listákon fejezet tárgyalja.

Karakterlánc (single-quoted)

Az aposztrófok közé írt karakterlánc (karakterlista) rövidítés: karakterkódok listája.

'erl' ≡ [?e,?r,?l] ≡ [101,114,108]

Ugyanez a ~c szigillel is írható: ~c"erl". A szigil speciális, „bűvös” jelölés az Elixirben. Az újabb Elixir-verziók a '...' jelölésre figyelmeztetnek, és a karakterlistát maguk is ~c"..." alakban írják ki.

Az Elixir/Erlang-héj a nyomtatható karakterkódokból (7..13, 27, 32..126) álló listát karakterláncként írja ki. Ha ezektől különböző érték is van a listában, listaként, számokkal írja ki:

iex> [101,114,108]
~c"erl"

iex> [31,101,114,108]
[31, 101, 114, 108]

iex> 'erl' ++ 'ang' # konkatenálható
~c"erlang"

Important

A karakterlánc NEM sztring! A 'abc' egy lista, a "abc" sztring (bináris); a lista- és a sztringműveletek különbözőek (lásd Sztring és bináris).

A kiírás tehát csak megjelenítés: a lista mindkét esetben számokból áll. Például a [0 | ~c"abc"] kifejezés eredménye [0, 97, 98, 99], mert a 0 nem nyomtatható karakter kódja, ezért az egész lista számokként jelenik meg. Egy mintaillesztés után a farka, ~c"bc", már megint karakterláncként látszik:

[_,_|xs] = [0 | ~c"abc"] |> IO.inspect
xs

[0, 97, 98, 99]
~c"bc"

Az Á kódja 193, ami kívül esik a 32..126 tartományon, ezért a ~c"Ábc" is számokkal jelenik meg ([193, 98, 99]), a farka (~c"bc") viszont nem.

A karakterlisták kiírása

Az inspect függvények kiírása a charlists: opcióval szabályozható: a charlists: :as_lists a lista elemeit számként, a charlists: :as_charlists karakterként jeleníti meg. Az alábbi példák az App3.app/2 listaösszefűző függvényt használják (Típusok):

IO.inspect(App3.app([], []))
IO.inspect(App3.app([5, 6, 7], [1, 2, 3]))
IO.inspect(App3.app([7, 10, 12], [97, 98, 99])) # Ha kiírható a karakterkód, akkor úgy is látjuk

[]
[5, 6, 7, 1, 2, 3]
~c"\a\n\fabc"

IO.inspect(App3.app([7, 10, 12], [97, 98, 99]), charlists: :as_lists) # Ha számként szeretnénk látni

[7, 10, 12, 97, 98, 99]

Az IO.inspect/2 kiírja és változatlanul továbbadja az értéket, az inspect/2 sztringgé alakítja, az IO.puts/1 pedig a sztringet idézőjelek nélkül írja ki:

App3.app([7, 10, 12], [97, 98, 99]) |> IO.inspect(charlists: :as_lists)
App3.app([7, 10, 12], [97, 98, 99]) |> inspect(charlists: :as_lists)
App3.app([7, 10, 12], [97, 98, 99]) |> inspect(charlists: :as_charlists)
App3.app([7, 10, 12], [97, 98, 99]) |> inspect(charlists: :as_charlists) |> IO.puts()

A négy kifejezés eredménye rendre a [7, 10, 12, 97, 98, 99] lista, a "[7, 10, 12, 97, 98, 99]" sztring, a "~c\"\\a\\n\\fabc\"" sztring, végül az IO.puts/1 kiírja a ~c"\a\n\fabc" szöveget, és :ok-t ad vissza.

A 0..127 tartományba eső ASCII-kódú karakterek megjelenési formáját így nézhetjük meg:

(for code <- 0..127, do: code) |> IO.inspect(charlists: :as_charlists)
[127] |> IO.inspect(charlists: :as_charlists)

~c"\0\x01\x02\x03\x04\x05\x06\a\b\t\n\v\f\r\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\e\x1C\x1D\x1E\x1F !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\d"
~c"\d"

A 7..13, 27 és 32..126 tartományon kívül eső kódú karakterek hexadecimális kódjukkal (\x01) vagy saját escape-szekvenciájukkal (\0, \d) jelennek meg. A nyomtatható karakterek teljes listáját a Műveletek listákon fejezet is bemutatja.

Forrás: dp26a-fp2ea.pdf (11–12. dia), dp26a-fp1gyfel.livemd

Sztring és bináris

Sztring (String, double quoted)

Az idézőjelek közé írt sztring UTF-8 kódolású karakterek ábrázolása bájtok sorozataként, azaz bináris típusú érték. Ennek két következménye van:

• az UTF-8 kódolás miatt a sztring (karakterekben mért) hossza kisebb lehet az őt ábrázoló bináris (bájtokban mért) hosszánál;
• a lista- és a sztringműveletek különbözőek.

iex> dxdy = "δx/δy"
"δx/δy"

iex> {String.length(dxdy), byte_size(dxdy)}
{5, 7}

iex> {String.at(dxdy,0), String.codepoints(dxdy)}
{"δ", ["δ", "x", "/", "δ", "y"]}

iex> [dx, dy] = String.split(dxdy, "/")
["δx", "δy"]

iex> dx <> "/" <> dy # <>: konkatenálás
"δx/δy"

A δ két bájton tárolódik, ezért az öt karakterből álló sztring hét bájt. A String modul függvényeit a Műveletek sztringeken fejezet tárgyalja.

Ami közös a karakterláncban és a sztringben

A karakterlánc és a sztring is UTF-8 kódolású karakterekből áll, és mindkettőben lehetnek ún. escape-szekvenciák:

Néhány karakter speciális jelentését az elé írt \ megszünteti, pl. \\ maga a visszaper-jel.

Mindkettő megengedi az ún. interpolációt, azaz egy kifejezés helyettesítését az értékével: "...#{<expr>}...".

iex> name = "dávid" # Sztring
"dávid"

iex> "Helló, #{String.capitalize name}!"
"Helló, Dávid!"

iex> bubo = 'Bubo' # Karakterlánc
~c"Bubo"

iex> "Helló, #{List.to_string [bubo, ? , "Réka"]}!"
"Helló, Bubo Réka!"

Az utolsó példában a ? (kérdőjel és szóköz) a szóköz karakter kódja; a List.to_string/1 a karakterláncból, a kódból és a sztringből álló listát egyetlen sztringgé alakítja.

Bináris (Binary)

A bináris típusba tartozó értékek bitsorozatok. Egy bináris érték jelölése << kif, ... >> alakú. A legegyszerűbb kif a [0,255] tartományba eső egész szám; a számokat bájtként tároljuk a binárisban:

iex> b = << 1, 2, 3 >>
<<1, 2, 3>>

iex> {byte_size(b), bit_size b}
{3, 24}

A tárolásra használt bitek száma a ::size(n) módosítóval megszabható. Az alábbi példában az 1 két biten (01), a második 1 három biten (001) tárolódik, együtt az öt bites 01001, ami decimálisan 9:

iex> b = << 1::size(2), 1::size(3) >> # 01 001
<<9::size(5)>> # = 9 (decimálisként)

iex> {byte_size(b), bit_size b}
{1, 5}

Egész és lebegőpontos számok és más értékek is tárolhatók binárisan. Itt a <<2.5>> a 2.5 lebegőpontos szám 64 bites ábrázolása:

iex> << <<1>> :: binary, <<2.5>> :: binary >>
<<1, 64, 4, 0, 0, 0, 0, 0, 0>>

A bináris tárolás hasznos médiafájlok és UTF-8 karakterek tárolására, processzek közötti kommunikációban stb.

Forrás: dp26a-fp2ea.pdf (13–15. dia)

Kulcs-érték lista és szótár

Kulcs-érték lista (Keyword list)

Egy kulcs-érték pár kételemű ennesként írható le: {:key, value}, ahol a kulcs csak atom, az érték tetszőleges típusú lehet. Az ilyen párokból álló listára gyakran van szükség, ezért az Elixir többféle jelölést, rövidítést, bizonyos esetekben zárójelelhagyást is megenged: [{:név, "Szöszi"}] helyett írható [név: "Szöszi"], és ha a kulcs-érték lista egy függvényhívás vagy egy ennes utolsó eleme, a szögletes zárójel is elhagyható.

iex> [{:név,"Szöszi"},{:szerelme,"jazz-zongorista"},{:város,"Prága"}]
[név: "Szöszi", szerelme: "jazz-zongorista", város: "Prága"]

iex> [név: "Szöszi", szerelme: "jazz-zongorista", város: "Prága"]
[név: "Szöszi", szerelme: "jazz-zongorista", város: "Prága"]

iex> inspect név: "Szöszi", szerelme: "jazz-zongorista", város: "Prága"
"[név: \"Szöszi\", szerelme: \"jazz-zongorista\", város: \"Prága\"]"

iex> [:cseh_film, név: "Szöszi", város: "Prága", szerelme: "zongorista"]
[:cseh_film, {:név, "Szöszi"}, {:város, "Prága"}, {:szerelme, "zongorista"}]

iex> {:cseh_film, név: "Szöszi", szerelme: "zongorista", város: "Prága"}
{:cseh_film, [név: "Szöszi", szerelme: "zongorista", város: "Prága"]}

A negyedik példában a lista első eleme atom, nem pár, ezért ez már nem kulcs-érték lista, és az Elixir a párokat ennesként írja ki. Az ötödikben a zárójel nélküli kulcs-érték lista az ennes második eleme lesz.

A kulcs-érték párokat leginkább függvényopciók megadására használjuk, pl. limit: :infinity, charlists: :as_lists.

Szótár (Map)

A szótár kulcs-érték párok rendezett kollekciója.

• Jelölése (map literal): %{ key1 => value1, key2 => value2, ...}.
• Ha a kulcs atom, alternatív jelölés: %{atom1: value1, atom2: value2}.
• A kulcsok és az értékek típusa tetszőleges, lehet kifejezés is; egy szótáron belül a kulcsok különböző típusúak lehetnek.

iex> states = %{"UA"=>"Ukraine", "SK"=>"Slovakia", "AT"=>"Austria"}
%{"AT" => "Austria", "SK" => "Slovakia", "UA" => "Ukraine"}

iex> msgs = %{{:error,:enoent} => :fatal, {:error,:busy} => :retry}
%{{:error, :busy} => :retry, {:error, :enoent} => :fatal}

iex> colors = %{:red=>0xff0000, :green=>0x00ff00, :blue=>0x0000ff}
%{green: 65280, red: 16711680, blue: 255}

iex> colors = %{red: 0xff0000, green: 0x00ff00, blue: 0x0000ff}
%{green: 65280, red: 16711680, blue: 255}

iex> mix = %{(&+/2).(3,2) => "három+kettő", fütty: "dal"<>"olka"}
%{5 => "három+kettő", :fütty => "dalolka"}

Az utolsó példában a (&+/2).(3,2) kulcskifejezés értéke 5. Ha a kulcsok vegyesen atomok és más értékek, az atom kulcsú párokat is ki lehet írni rövid alakban, de csak a lista végén (fütty: ...).

A szótárt elsősorban asszociatív tömbként szokás használni. Értéket a kulccsal, szögletes zárójeles jelöléssel nyerünk ki belőle; ha nincs ilyen kulcs, az eredmény nil. Ha a kulcs atom, a rövidebb pontos jelölés is használható:

iex> states["UA"]
"Ukraine"

iex> states["HU"]
nil

iex> msgs[{:error, :busy}]
:retry

iex> colors[:green]
65280

iex> colors.red
16711680

iex> mix[(&Kernel.*/2).(1,5)]
"három+kettő"

iex> mix.fütty
"dalolka"

További részletek a Map modul dokumentációjában találhatók.

Forrás: dp26a-fp2ea.pdf (16–18. dia)

Reguláris kifejezés

Az Elixirben a reguláris kifejezés (Regex) is önálló típus. Jelölése ~r{regexp} vagy ~r{regexp}options. A ~r{...} jelölés is szigil, azaz bűvös jelölés; a szigilekről részletek a Kernel dokumentációjában találhatók. A reguláris kifejezés szintaxisa a PCRE (Perl Compatible Regular Expressions, http://www.pcre.org) szerinti.

A Regex.run/2 az első illeszkedést adja vissza, a Regex.scan/2 az összeset, a Regex.split/2 az illeszkedések mentén darabolja a sztringet, a Regex.replace/3 pedig lecseréli az illeszkedő részeket:

iex> Regex.run ~r{[cdr]}, "madárcsicsergés"
["d"]

iex> Regex.scan ~r{[cdr]}, "madárcsicsergés"
[["d"], ["r"], ["c"], ["c"], ["r"]]

iex> Regex.split ~r{[cdr]}, "madárcsicsergés"
["ma", "á", "", "si", "se", "gés"]

iex> Regex.replace ~r{[cdr]}, "madárcsicsergés", "."
"ma.á..si.se.gés"

A regexp után egy vagy több egykarakteres opció állhat:

Az alábbi példákban a cs.*s minta cs-vel kezdődő, s-re végződő részt keres. Opció nélkül csak a kisbetűs cs-re illeszkedik, és a mohó .* a lehető leghosszabb részt veszi; az i opcióval a nagybetűs Cs is illeszkedik; az U opcióval a .* lusta lesz, így a legrövidebb illeszkedést kapjuk:

iex> Regex.run ~r{cs.*s}, "Madarak Csicsergése"
["csergés"]

iex> Regex.run ~r{cs.*s}i, "Madarak Csicsergése"
["Csicsergés"]

iex> Regex.run ~r{cs.*s}iU, "Madarak Csicsergése"
["Csics"]

További részletek a Regex modul dokumentációjában találhatók.

Forrás: dp26a-fp2ea.pdf (19–20. dia)

Termek, azonosítók, változók

Term

A term tetszőleges adatstruktúra. Minden termnek van értéke és típusa, és a term maga is kifejezés. Közelítő rekurzív definíciója: szám-, atom-, függvény- és más értékekből, illetve termekből konstruktorokkal felépített, tovább nem egyszerűsíthető kifejezés.

A term tehát tovább nem egyszerűsíthető és tömör: kiértékelhető, azaz nincs benne szabad változó. Ha a kötött változó értéke már kötött = 2021, akkor az alábbiak termek:

123456789
{'Diák Detti', [{:khf, [:prolog, :elixir, :prolog]}]}
[&:erlang.+/2, kötött, fn(x,y) -> x*y end]

Nem termek viszont azok a kifejezések, amelyek tovább egyszerűsíthetők vagy nem tömörek:

5+6                   # műveletet tartalmaz
(&:erlang.+/2).(5,6) # függvényalkalmazást tartalmaz
szabad                # szabad változó

Azonosító (identifier)

Az azonosító kisbetűvel vagy aláhúzásjellel (_) kezdődő, betűket, számjegyeket és aláhúzásjeleket tartalmazó, opcionálisan kérdő- vagy felkiáltójellel végződő karaktersorozat. A betű és a számjegy UTF-8 kódolású betű, illetve decimális számjegy lehet (lásd https://hexdocs.pm/elixir/unicode-syntax.html). Az azonosító változót vagy függvénynevet jelöl.

Konvenciók:

• a ?-lel végződő azonosító kiértékelése igazságértéket ad eredményül;
• a !-lel végződő azonosító kiértékelése kivételt dob, ha meghiúsul;
• az azonosító részeit aláhúzásjellel tagoljuk (ún. megengedő snake_case; vö. az atom szintaxisával).

what_s_in_a_name   name?   exec!
_unused   rómeó_és_Júlia   year_2021

Változó

Egy változó lehet szabad vagy kötött. A szabad változónak nincs értéke és típusa; a kötött változó valamely konkrét term szinonimája.

A változóhoz új érték köthető, de ez a korábbi felhasználását nem módosítja: a korábban kiértékelt kifejezések a régi értéket használták. A ^ (pin) operátor a kötött változó értékét fixálja: így a változó nem köthető új értékhez, hanem a mintaillesztésben a meglévő értékével vesz részt.

iex> x = fn(x) -> 2*x end # a külső és a belső x nem ugyanaz!
#Function<44.40011524/1 in :erl_eval.expr/5>

iex> y = x
#Function<44.40011524/1 in :erl_eval.expr/5>

iex> ^x = y.(2)
** (MatchError) no match of right hand side value: 4
iex> x = y.(2)
4

iex> y
#Function<44.40011524/1 in :erl_eval.expr/5>

A ^x = y.(2) meghiúsul, mert x értéke itt a függvény, nem a 4. Az x = y.(2) után x új értéke 4, de y továbbra is a függvényt jelöli, mert a kötésekor x még a függvény volt.

Változó hatásköre

A változók hatásköre lexikális:

• A függvény törzsében és fejében definiált változók (az utóbbiak másnéven a formális paraméterek) lokálisak a függvényre nézve.
• Modulban is lehet változót definiálni, de az csak modulszinten látható, a modulban definiált függvényekből nem.
• A with kifejezéssel is definiálhatunk lokális változót: a with után kötött változók csak a do: utáni kifejezésben látszanak.

iex> with a = 5, b = 7, do: a*a + 2*a*b + b*b
144

iex> a = 11; with a = 5, b = 7, do: a*a + 2*a*b + b*b; a
11

A második példában a with-en belüli a = 5 nem változtatja meg a külső a értékét, amely 11 marad. A ; egy sorban választ el kifejezéseket.

Komment

A komment # jellel kezdődik, és a sor végéig tart.

Forrás: dp26a-fp2ea.pdf (22–25. dia)

Műveletek és beépített függvények

Aritmetikai és bitműveletek

Aritmetikai műveletek (a Kernel modulban), a precedencia szerint csoportosítva (kisebb szám: erősebb kötés):

• előjel: +, - (precedencia: 1);
• multiplikatív műveletek: *, /, div, rem (precedencia: 2);
• additív műveletek: +, - (precedencia: 3).

Bitműveletek (a Bitwise modulban):

• bnot vagy ~~~, band vagy &&& (precedencia: 2);
• bor vagy |||, bxor, bsl vagy <<<, bsr vagy >>> (precedencia: 3).

Szabályok:

• +, -, * és / egész és lebegőpontos operandusokra is alkalmazhatók;
• +, - és * eredménye egész, ha mindkét operandusuk egész, egyébként lebegőpontos;
• / eredménye mindig lebegőpontos;
• div (egészosztás) és rem (maradék) prefix helyzetűek, például div(7, 2); eredményük egész;
• div, rem és a bitműveletek operandusai csak egészek lehetnek;
• ~~~, &&&, |||, <<<, >>> infix, a többi bitművelet prefix helyzetű.

A bitműveleteket használat előtt importálni kell:

import Bitwise

Ekkor például 5 &&& 3 értéke 1, bnot(5) értéke -6, 1 <<< 4 értéke 16. A régebbi anyagokban szereplő use Bitwise[, (only_operators | skip_operators): true] alak az újabb Elixir-verziókban elavult, figyelmeztetést ad.

Összehasonlító műveletek (relációk)

Egy reláció (összehasonlítás) eredménye a true vagy a false atom.

• Kisebb, kisebb-egyenlő, nagyobb-egyenlő, nagyobb: <, <=, >=, >.
• Érték szerinti egyenlőség (integer és float lehet egyenlő): ==, !=.
• Szigorú egyenlőség (integer és float nem lehet egyenlő): ===, !==.

Például 5.0 == 5 értéke true, 5.0 === 5 értéke false.

Különböző típusú termek is összehasonlíthatók. A típusok sorrendje (vö. Típusok):

number < atom < reference < function < port < pid < tuple < map < list < binary

Lebegőpontos értékek összehasonlítása

Elrettentő példák: a lebegőpontos számok kettes számrendszerben csak közelítőleg ábrázolhatók, ezért az egyenlőségvizsgálat meglepő eredményt adhat.

iex> 10.1 - 9.9 == 0.2
false

iex> (10.1 - 9.9) * 10
1.999999999999993

iex> 0.000000000000001 + 1 == 1
false

iex> 0.0000000000000001 + 1 == 1
true

Warning

Lebegőpontos értékek egyenlőségének vizsgálata helyett vizsgáljuk a különbségüket a <= vagy >= relációval: ε-nál kisebb-e a különbségük?

Logikai műveletek

• Prefix helyzetű operátor: not és !. A not operandusa csak boolean lehet, a !-é tetszőleges típusú kifejezés.
• Infix helyzetű operátorok: and és &&, or és ||.
  • not, and és or használható őrkifejezésben (lásd Mintaillesztés), !, && és || nem.
  • and és or első operandusa csak boolean lehet, && és || első operandusa tetszőleges típusú kifejezés.
  • A false és nil értékű kifejezéseket kivéve minden más érték true-nak számít.
  • A második operandusuk tetszőleges típusú kifejezés lehet.
  • Eredményük típusa a két operandus típusának uniója.
  • Lusta kiértékelésű, ún. short-circuit műveletek: ha az első operandus kiértékelése eldönti az eredményt, a másodikra nem kerül sor.

iex> !:atom && div(3,0) === 2
false

iex> :atom && div(3,0) === 2
** ...bad argument in ...: div(3, 0)
iex> :atom and rem(3,2) === 1
** ...expected a boolean on left-side of "and"
iex> true and rem(3,2)
1

iex> false and rem(3,2)
false

iex> nil && rem(3,2)
nil

Az első példában a !:atom értéke false, ezért a && a második operandust, a nullával való osztást ki sem értékeli. A másodikban :atom igaznak számít, így az osztásra sor kerül, és hibát ad. A harmadikban az and első operandusa nem boolean, ez hiba. A true and rem(3,2) eredménye a második operandus értéke, 1, tehát nem feltétlenül boolean.

Beépített függvények (Built-In Functions, BIFs)

A BIF-ek a BEAM-be beépített, rendszerint C-ben írt függvények. Többségük az erts Erlang-könyvtár erlang moduljának része; az Elixir-specifikációjuk az Elixir Kernel moduljában található. A csak az Erlang erlang moduljában definiált BIF-ek az :erlang modulnévvel hívhatók.

Az alaptípusokon alkalmazható leggyakoribb BIF-ek:

• Számok: abs(num), trunc(num), ceil(num), floor(num), round(num), :erlang.float(num). Az :erlang.float helyett 1-gyel is oszthatjuk az egész számot, pl. 5/1.
• Sztring, bináris: bit_size(string), byte_size(string).
• Szótár: map_size(map).
• Ennes: tuple_size(tuple), elem(tuple, index), put_elem(tuple, index, value), ahol 0 ≤ index ≤ tuple_size(tuple)-1.
• Lista: length(list), hd(list), tl(list).

Az operátorok is BIF-ek a Kernel-ben, például Kernel.*(3,4).

Típusvizsgálat és típuskonverzió

Típusvizsgálat (BIF-ek a Kernel-ben):

• is_integer(term), is_float(term), is_number(term),
• is_atom(term), is_boolean(term), is_nil(term),
• is_binary(term), is_bitstring(term),
• is_tuple(term), is_list(term), is_map(term),
• is_function(term), is_function(term, arity).

Típuskonverzió (az egyes típusokhoz tartozó modulokban, pl. Atom.to_string/1):

• Atom: to_charlist(atom), to_string(atom);
• Float: to_charlist(float), to_string(float);
• Integer: to_charlist(integer), to_string(integer);
• List: to_atom(list), to_charlist(list), to_float(list), to_integer(list), to_integer(list, base), to_string(list), to_tuple(list);
• String: to_atom(string), to_charlist(string), to_float(string), to_integer(string), to_integer(string, base);
• Tuple: to_list(tuple);
• Map: to_list(map).

Forrás: dp26a-fp3ea.pdf (17–21. dia)

Mintaillesztés

Az Elixir – más funkcionális, illetve deklaratív nyelvekhez hasonlóan – mintaillesztést (pattern matching) használ a különféle esetek felismerésére és szétválasztására, valamint változók értékhez kötésére.

Minta és mintaillesztés

A mintakifejezés, röviden minta, termhez hasonló olyan kifejezés, amelyben nincs függvénykifejezés, de lehet benne szabad változó (a term és a szabad változó fogalmát lásd: Termek, azonosítók, változók).

• A konstansok csak velük azonos értékre illeszkednek, pl. 123, [], [1,2,3], ~c"abc", "abc", :eof, nil, true.
• A kötött, azaz értékkel rendelkező változók csak velük azonos értékre illeszkednek.
• Egy szabad (kötetlen), azaz értékkel nem rendelkező változó mindenre illeszkedik, és sikeres illesztéskor az illeszkedő kifejezés megfelelő részéhez kötjük; ezután hivatkozhatunk rá.
• Az aláhúzásjel (_, a névtelen változó) és az aláhúzásjellel kezdődő változónév is mindenre illeszkedik. Az előbbire nem lehet, az utóbbira nem szokás hivatkozni.
• Egy mintában ugyanaz a változó többször is előfordulhat, ha mindenütt azonos értékre kell illeszkednie.
• Kifejezés nem lehet minta, pl. 1+x, 1+2, round(x), round(5.3).

A mintaillesztés műveleti jele az =, a bal oldalán a mintával, a jobb oldalán egy tömör kifejezéssel: a mintaillesztés egyirányú. A mintaillesztés a minta nem fixált (vö. ^ operátor) változóit értékhez köti.

Important

A kötés nem értékadás! Az = nem írja felül a változó értékét egy tárolóban, hanem a bal oldali mintát illeszti a jobb oldali értékre, és a minta szabad változóit a megfelelő részekhez köti.

Változóhoz kétféleképpen köthetünk értéket:

• az = mintaillesztés- vagy kötésoperátorral,
• paraméterátadással függvényhíváskor: az aktuális paramétereket illesztjük a formális paraméterekre az egyes klózokban.

Ha egy változót értékhez kötünk, de nem használjuk, az Elixir figyelmeztet rá, kivéve akkor, ha a változónév _-sal kezdődik.

A Prologban – a funkcionális nyelvekkel ellentétben – kétirányú mintaillesztés van, ennek egyesítés a neve.

Néhány egyszerű eset:

• x = 5 az x mintát illeszti az 5 kifejezésre, x értéke 5 lesz.
• [hd|tl] = valami() a hd és tl változókat a valami() által visszaadott lista fejéhez és farkához köti. Ha a valami() üres listával (vagy bármi mással) tér vissza, a kiértékelés hibával leáll: (MatchError) no match of right hand side value.
• Az [x | xs] minta a legalább egyelemű listákra illeszkedik: x a lista fejének, xs a farkának az értékét veszi fel; az utóbbi lehet üres is.
• Az [x1, x2 | xs] minta a legalább kételemű listákra illeszkedik: x1 a lista első, x2 a második elemének, xs a farkának az értékét veszi fel.
• Az [_|xs] minta is a legalább egyelemű listákra illeszkedik, de a lista fejét a névtelen változóhoz köti, azaz eldobja.
• Az [_,_|_] minta a legalább kételemű listákra illeszkedik, de az elemek értékével nem kezd semmit.

iex> 123 = 123
123

iex> 123 = 321
** (MatchError) no match of right hand side value: 321
iex> ~c"abc" = [97, 98, 99]
~c"abc"

iex> :eof = :eof
:eof

iex> nil = nil
nil

Listamintákkal:

[x|xs] = ~c"abc" |> IO.inspect
{x, xs}

~c"abc"
{97, ~c"bc"}

[_,_|xs] = ~c"abc" |> IO.inspect
xs

~c"abc"
~c"c"

[_|xs] = ~c"Ábc" |> IO.inspect
xs

[193, 98, 99]
~c"bc"

(Hogy miért jelenik meg az egyik lista karakterekkel, a másik számokkal, azt a Lista és karakterlánc fejezet magyarázza.)

Kifejezést tartalmazó minta fordítási hibát ad:

defmodule BadPattern do
  def fun(x < 0), do: x
end

defmodule BadPattern do
  def fun(round(x)), do: x
end

1+2 = 1+2

Mindhárom esetben a hibaüzenet: cannot invoke remote function ... inside a match (az :erlang.</2, az :erlang.round/1, illetve az :erlang.+/2 függvényre).

Példák mintaillesztésre

Függvényérték nem lehet minta, és a & sem állhat mintában; szabad változó viszont illeszkedhet függvényértékre. Szabad változó a jobb oldalon nem állhat:

iex> [x, &+/2] = [5, &+/2]
** (CompileError) ... & is not allowed in matches
iex> [x, f] = [5, &+/2]
[5, &:erlang.+/2]

iex> [x, f] = [5, f]
[5, &:erlang.+/2]

iex> a = fn(x) -> x+1 end
#Function<44.40011524/1 in :erl_eval.expr/5>

iex> {a, b} = {fn(x) -> x+1 end, 23}
{#Function<44.40011524/1 in :erl_eval.expr/5>, 23}

iex> fn(x) -> x+1 end = a
** (CompileError) ... fn is not allowed in matches
iex> 3 = szabad
** (CompileError) iex:505: undefined function szabad/0

A [x, f] = [5, f] sikerül, mert a jobb oldalon f már kötött, az értéke a függvény. Listamintákkal:

iex> [z | zs] = [0,1,2,3]
[0, 1, 2, 3]

iex> [z1 | [z2 | [z3 | [z4 | zs]]]] = [0,1,2,3]
[0, 1, 2, 3]

iex> [z1, z2, z3 | [3]] = [0,1,2,3]
[0, 1, 2, 3]

iex> [z1, z2, z3 | 3] = [0,1,2,3]
** (MatchError) no match of right hand side value: [0, 1, 2, 3]
iex> [z1, z2 | [3]] = [0,1,2,3]
** (MatchError) no match of right hand side value: [0, 1, 2, 3]

A [z1, z2, z3 | 3] minta azért nem illeszkedik, mert a negyedik elem utáni farok nem a 3 szám, hanem a [3] lista; a [z1, z2 | [3]] pedig csak háromelemű listára illeszkedhetne.

Ennesmintákkal; ugyanaz a változó többször is előfordulhat a mintában:

iex> {{a, b}, {a, b}} = {{:a, :b}, {:a, :b}}
{{:a, :b}, {:a, :b}}

iex> {{a, b, a}} = {{:a, :b, :b}}
** (MatchError) no match of right hand side value: {{:a, :b, :b}}
iex> {a, b, _b, _} = {:a, :b, :b, :a}
{:a, :b, :b, :a}

iex> {a, b}
{:a, :b}

iex> _b
warning: the underscored variable "_b" is used after being set...
please rename the variable to remove the underscore
:b

Az _b kötött ugyan, de mivel aláhúzásjellel kezdődik, a rá való hivatkozásra az Elixir figyelmeztet.

Szótármintákkal. A szótárminta részleges: elég, ha a mintában szereplő kulcsok megvannak a szótárban. Kulcs helyén szabad változó nem állhat. A ^ fixálja a változó értékét:

iex> x = %{b: "barna", z: "zöld"}
%{b: "barna", z: "zöld"}

iex> %{k1: v1, k2: v2} = x
** (MatchError) no match of right hand side value: %{b: "barna", z: "zöld"}
iex> %{k1 => v1, k2 => v2} = x
** (CompileError) iex:3: cannot use variable k1 as map key inside a pattern...
iex> %{b: v1, z: v2} = x
%{b: "barna", z: "zöld"}

iex> {v1, v2}
{"barna", "zöld"}

iex> %{z: ^v1, b: v2} = x
** (MatchError) no match of right hand side value: %{b: "barna", z: "zöld"}
iex> %{z: v1, b: v2} = x
%{b: "barna", z: "zöld"}

iex> {v1, v2}
{"zöld", "barna"}

iex> %{b: v} = x # részleges mintaillesztés
%{b: "barna", z: "zöld"}

iex> v
"barna"

A %{z: ^v1, b: v2} = x azért hiúsul meg, mert v1 értéke ekkor "barna", a :z kulcshoz tartozó érték pedig "zöld".

Réteges minta

A réteges minta (layered pattern) minta = változó alakú: a változó a teljes illesztett értékhez kötődik, a minta pedig a részeihez. Így egyszerre hivatkozhatunk az egészre és a komponenseire:

iex> ([y|ys] = yss) = [1, 2, 3] # réteges minta (layered pattern)
[1, 2, 3]

iex> {y, ys, yss}
{1, [2, 3], [1, 2, 3]}

Függvény paraméterében is használható. Az alábbi [z | zs] = zzs mintával a klóz törzsében a teljes listára zzs-sel, a fejére z-vel, a farkára zs-sel hivatkozhatunk:

  def app([z | zs] = zzs, ys) do
    [z | app(zs, ys)]
  end

A réteges minta további haszna a Klózok szakaszban látható.

Mintaillesztés case kifejezéssel

A case kifejezés a kapott értéket sorban illeszti az ágak mintáira, és az első illeszkedő ág kifejezését értékeli ki:

case valami() do
  [hd|tl] -> ... # Ha nem üres lista
  [] -> ... # Ha üres lista
  _ -> ... # Bármi más
end

Őr

A mintában csak tömör, azaz kiértékelhető kifejezés lehet, változót tartalmazó kifejezés nem. Ilyesmit tehát nem írhatunk le:

def fac(n >= 0), do: ...

Az ilyen esetek gyakoriak, ezért a minta ún. őrrel (guard) egészíthető ki. Az őrt a függvényfejben a paraméter(eke)t követő when kulcsszó vezeti be, utána őrkifejezés áll:

  def fac(n) when n >= 0, do: ...

Az őrkifejezésben csak őrként (guard) definiált, garantáltan mellékhatás nélküli könyvtári függvényeket hívhatunk, más függvényeket, így saját függvényeket sem. Ilyenek például a típusvizsgáló is_... függvények és a not, and, or műveletek (lásd Műveletek és beépített függvények).

Őr a case ágaiban is állhat. Az alábbi case kifejezés egészekkel kezdődő nem üres listára a fej kétszeresét, üres listára 0-t, bármi másra nil-t (hibajelzést) ad:

case valami() do
  [hd|tl] when is_integer(hd) -> hd * 2 # Ha nem üres lista
  [] -> 0 # Ha üres lista
  _ -> nil # Bármi más: hibajelzés
end

Klózok

Egy függvényt több klózzal definiálhatunk: minden előforduló esetre egy-egy klózt írunk, és a függvény hívásakor az első olyan klóz törzse értékelődik ki, amelynek mintájára (és őrére) az aktuális paraméterek illeszkednek. Minden klóz független a többitől: a paramétereik neve lehet azonos, de különböző is; egy klóz törzsében csak a saját paramétereire lehet hivatkozni.

Ha egyik klóz sem illeszkedik, a hívás FunctionClauseError hibával leáll. Például ha az összefűzés első változata csak az üres listát kezeli:

defmodule App0 do
  # app(xs, ys): xs és ys listák összefűzöttje zs == (xs ⊕ ys)
  # [] ⊕ ys == ys
  def app([], ys), do: ys
end

akkor az App0.app([], ~c"abc") eredménye ~c"abc", az App0.app([1,2,3], ~c"abc") viszont FunctionClauseError hibát ad. A hiányzó eset tehát nem fordítási hiba, hanem futás közben derül ki. A dialyzer (Típusellenőrzés: dialyzer) sem jelzi a hiányzó eseteket; csak akkor figyelmeztet, ha be tudja bizonyítani, hogy egy hívás soha nem lehet sikeres.

Egymást kölcsönösen kizáró minták

Egy függvény klózainak mintái lehetőleg zárják ki kölcsönösen egymást. Tegyük fel például, hogy egy függvénynek – az üres listát nem kezelve – azt kell megkülönböztetnie, amikor a listának pontosan egy eleme van, attól, amikor legalább egy eleme van:

def fun([x|xs])...
def fun([x])...

Ezzel az a gond, hogy az első klóz minden olyan listára illeszkedik, amelynek van feje, a farka pedig tetszőleges elemszámú, azaz üres is lehet. Ezért az első klóz az egyelemű listára is illeszkedik, a második klózra soha nem kerül sor: a minták nem zárják ki kölcsönösen egymást (erre az Elixir-fordító figyelmeztet is). A két klóz sorrendjének megfordításával a mintaillesztés már meg tudja különböztetni a két esetet, ám ennek hatékonyságromlás az ára:

def fun([x])...
def fun([x|xs])...

Írhatunk azonban olyan mintát is, amely a legalább kételemű listákra illeszkedik, és így kölcsönösen kizárja a pontosan egyelemű listára illeszkedő mintát:

def fun([x1,x2|xs])...
def fun([x])...

Az első klóz törzsében a lista fejére az x1 változóval, a farkára az [x2|xs] kifejezéssel hivatkozhatunk. Ez utóbbi hivatkozást egyszerűbbé (és olcsóbbá) teszi a réteges minta; a lista farkára ekkor az xxs változóval hivatkozunk:

def fun([x1 | xxs = [x2|xs]])...
def fun([x])...

Ha az x2 és xs változókat nem használjuk a klóz törzsében, az Elixir-fordító figyelmeztet. A figyelmeztetést úgy kerülhetjük el, hogy a változó nevét aláhúzásjellel kezdjük, vagy elég csak aláhúzásjelet írni:

def fun([x1 | xxs = [_x2|_xs]])...
def fun([x1 | xxs = [_|_]])...

A beszédes nevek azonban segítik a megértést, utalnak a változó szerepére. Ha a lista második elemére vagy a harmadik elemtől kezdődő farkára hivatkozni akarunk a klóz törzsében, akkor ne aláhúzásjellel kezdődő változóneveket használjunk.

Forrás: dp26a-fp1ea.pdf (22. dia), dp26a-fp3ea.pdf (23–26. dia), dp26a-fp1gyfel.livemd, dp26a-fp2gy-megoldasok.livemd, dp26a-fp1gy-megoldasok.livemd

Rekurzió

Lineáris és elágazó rekurzió

A deklaratív programozás alappillére a rekurzió. A deklaratív nyelvekben nincs ciklus, ezért ismétlést, iterációt is rekurzív algoritmussal valósítunk meg. A rekurzió kétféle lehet: lineáris és elágazó (angolul linear recursion és tree recursion).

• Lineáris rekurzió: egy rekurzív hívás van a függvényben.

  def fac(0), do: 1 # 1. klóz: Alapeset
  def fac(n), do: n * fac(n - 1) # 2. klóz: Rekurzív eset
  

• Jobbrekurzió (farokrekurzió, tail recursion): a rekurzív hívás visszatérési pozícióban van, ezért hatékonyabb gépi kód készül belőle, nem kell hozzá verem.

  def fac(n), do: fac(n, 1) # Segédfüggvény meghívása akkumulátor paraméterrel
  def fac(0, a), do: a
  def fac(n, a), do: fac(n - 1, n * a)
  

• Elágazó rekurzió: több rekurzív hívás van a függvényben; sokszor nem hatékony (lásd Dinamikus programozás).

  def fib(n) when n <= 1, do: n # 1. klóz őrfeltétellel: Alapeset
  def fib(n), do: fib(n - 1) + fib(n - 2) # 2. klóz: Rekurzív eset
  

Az adatszerkezetek is lehetnek rekurzívak:

• Lineárisan rekurzív adatszerkezet pl. az egyszeresen láncolt lista ([...], nem egydimenziós tömb!). Alapesete az [] üres lista, rekurzív esete a legalább egyelemű [H|T], ahol T is egy lista ([] vagy legalább egyelemű).
• Elágazóan rekurzív adatszerkezet pl. a (bináris vagy többágú) fa.

Rekurzív adatszerkezetek feldolgozásának természetes módja a rekurzív algoritmus. Lineáris adatszerkezetek, pl. listák feldolgozására imperatív nyelveken még lehet ciklust írni, de elágazóan rekurzív adatszerkezeteket, pl. fákat ciklusokkal bejárni már nagy kihívás. Ez az algebrai módszer: a rekurzív adatszerkezeteket mintaillesztéssel dolgozzuk fel rekurzív függvényekkel, minden esetre egy-egy klózt írva.

Rekurzív függvény írása: két lista összefűzése

A deklaratív stílus érzékeltetésére írjuk meg lépésről lépésre két lista összefűzését app/2 néven! Az xs és ys listák összefűzése azt jelenti, hogy az xs lista összes elemét az ys elé fűzzük az elemek eredeti sorrendjének megőrzésével: xs⊕ys.

Mivel a lista láncolt adatszerkezet, csak az első elemét érjük el közvetlenül. Egyszerű a dolgunk, ha az első lista, xs, üres: ekkor a második listát, ys-t kell változtatás nélkül visszaadnunk. Ezt az esetet már láttuk (App0, Mintaillesztés).

Ugyanez a rövidített (, do:) függvénydefiníció helyett a teljes, do ... end alakú definícióval:

defmodule App0 do
  # app(xs, ys): xs és ys listák összefűzöttje zs == (xs ⊕ ys)
  # [] ⊕ ys == ys
  def app([], ys) do
    ys
  end
end

Ha xs nem üres, akkor ahhoz, hogy az ys elé fűzzük, rendre le kell emelni és félre kell rakni az elemeit, amíg csak üressé nem válik. Hová tegyük ezeket az elemeket? Ha a függvény rekurzív módon hívja meg saját magát, akkor átmenetileg automatikusan a hívási verembe kerülnek.

Amikor rekurzív függvényt írunk, abból indulunk ki, hogy a függvény valamilyen egyszerűbb adatszerkezetre – pl. egy paraméterként kapott lista farkára – elvégzi, amit elvárunk tőle, és ezután már csak a lista fejével kell valamit kezdenie, pl. a rekurzív hívás eredményeként kapott lista elé fűznie. A mintaillesztéssel az előforduló eseteket világosan elkülöníthetjük. Két lista összefűzésénél az első paraméter, xs, értéke szerint két esetet érdemes megkülönböztetni (lehetne többet is, de felesleges lenne): 1. xs nem üres, 2. xs üres.

defmodule App1 do
  # app(xs, ys): xs és ys listák összefűzöttje zs == (xs ⊕ ys)

  # [z | zs] ⊕ ys = [z | zs ⊕ ys]
  def app([z | zs] = zzs, ys) do
    [z | app(zs, ys)]
  end

  # [] ⊕ ys == ys
  def app([], ys) do
    ys
  end

end

A [z | zs] = zzs réteges minta (lásd Mintaillesztés) csak a magyarázat kedvéért szerepel, hogy a teljes paraméterre is utalni tudjunk, ne csak a komponenseire. Mivel a törzsben nem használjuk, a fordító figyelmeztetésének elkerülésére aláhúzásjellel kezdjük:

defmodule App2 do
  # app(xs, ys): xs és ys listák összefűzöttje zs == (xs ⊕ ys)
  def app([z | zs] = _zzs, ys) do
    [z | app(zs, ys)]
  end

  def app([], ys) do
    ys
  end
end

Ha az app/2 hívásakor az első paraméter üres lista, az Elixir a második klózt értékeli ki, ha nem üres, az elsőt. Az első klóz rekurzív hívásában az app/2-t a kapott _zzs lista farkára, zs-re alkalmazzuk, feltételezve, hogy képes a zs listát az ys elé fűzni. Amikor ebből a hívásból visszatér, már csak a verembe félretett z-t kell a kapott lista elé fűznie ([z | app(zs, ys)]).

Két dolgot kell még belátnunk.

• A rekurzió nem végtelen. A listák véges hosszúságúak, és a rekurzív hívás az app/2-t mindig a kapott _zzs-nél eggyel rövidebb zs-re alkalmazza. A lista tehát egyre rövidül, és amikor üressé válik, a második klóz kiértékelésére kerül sor: ennek törzsében nincs rekurzív hívás, a függvény a rekurzív hívások során változás nélkül továbbadott ys-sel tér vissza.
• A függvény azt csinálja, amit elvárunk tőle. Amikor a lista már üressé vált, a rekurzív hívás az ys listával tér vissza; ez elé fűzi az első klóz az eredeti lista utolsó elemét, amelyet a veremből vesz elő. A következő visszatéréskor az így kibővített lista elé fűzi az utolsó előtti elemet, majd a hátulról harmadikat, és így tovább, amíg ki nem ürül a verem. A végeredmény valóban az, amit várunk.

iex> App2.app([1,2,3], [4,5])
[1, 2, 3, 4, 5]

Ha a klóz törzse egyetlen kifejezésből áll, célszerű a rövidített , do: függvényjelölést alkalmazni; a típusspecifikációval és a fejkommenttel kiegészített tömör változat az App3 (Típusok). Ellenőrizzük, hogy lefedtünk-e minden lehetséges esetet! Az első paraméter a két klózban kétféle mintára illeszkedhet, []-ra vagy [x|xs]-re, azaz üres vagy legalább egyelemű listára: ez lefedi az első paraméter összes lehetséges (lista) értékét. A második paraméter mindkét klózban az ys kötetlen változó, ami mindenre illeszkedik. A két klózzal tehát valóban minden esetet lefedtünk.

Törzsrekurzió és jobbrekurzió

A rekurzió szokásos iskolapéldája az $n!$ kiszámítása. Matematikai definíciója:

$$0!=1,n!=n\cdot (n-1)!,\text{ ha }n>0$$

Az első változat a matematikai definíciót másoló rekurzív függvény:

defmodule Fac do
  @spec fac(n :: integer()) :: f :: integer() # Típusspecifikáció
  # f = n! (azaz f az n faktoriálisa) # Fejkomment

  # ha az n=0 mintaillesztés sikeres
  def fac(0), do: 1

  # ha az n=0 mintaillesztés sikertelen
  def fac(n), do: n * fac(n - 1)
end

A második klózban alkalmazott rekurziót angolul body recursion-nek, magyarul törzsrekurziónak mondhatjuk, ha hangsúlyozni akarjuk, hogy a rekurzív hívás eredményével a függvény törzsében még további műveletet (itt szorzást) kell végezni.

A jobbrekurzív (tail recursive) változat kevésbé szigorúan követi a matematikai definíciót, ezért nehezebb megérteni, és nehezebb hozzá kifejező, pontos fejkommentet írni. A jobbrekurziót magyarul terminális rekurziónak, ritkábban farokrekurziónak is nevezik, mert a rekurzív hívás az adott klózban az utolsó – befejező, lezáró – hívás: az eredményét változatlanul vissza kell adni, már semmilyen műveletet nem végzünk vele.

A jobbrekurzív változathoz egy plusz paraméterre van szükség. Ezt akkumulátornak szokták nevezni, mert a részeredményeket gyűjtjük benne – ahelyett, hogy a még elvégzendő műveleteket az argumentumaikkal együtt a verembe tennénk. Itt a részletszorzatokat adjuk át benne a rekurzív hívásban.

Az akkumulátornak az első híváskor adunk értéket: a fac/1 hívja meg az 1 kezdőértékkel a fac/2-t. Ha a fac/1-et $0$-val hívjuk, az eredménynek $1$-nek kell lennie, ezért a fac/2 első klózának $0$ esetén az akkumulátort kell visszaadnia, rekurzív hívás nélkül. Ha az első paraméter, $n$, nem $0$, a második klózra kerül sor: a rekurzív hívásban az első paramétert eggyel csökkentjük ($n-1$), a másodikban pedig $n$-nel megszorozzuk az eddig összegyűjtött részletszorzatot ($n\ast a$). Így alakul ki az $n\cdot (n-1)\cdot \dots \cdot 1$ eredmény.

defmodule FacJobbrek do
  # Típusspecifikáció
  @spec fac(n :: integer()) :: f :: integer()
  # f = n! (azaz f az n faktoriálisa)
  def fac(n), do: fac(n, 1)

  @spec fac(n :: integer(), a :: integer()) :: f :: integer()
  defp fac(0, a), do: a
  defp fac(n, a), do: fac(n - 1, n * a)
end

Mindkét változatot kipróbálhatjuk ugyanazokkal a hívásokkal:

Fac.fac(5)
Fac.fac(0)
Fac.fac(1)
Fac.fac(100_000)
FacJobbrek.fac(5)
FacJobbrek.fac(0)
FacJobbrek.fac(1)
FacJobbrek.fac(100_000)

Az eredmény mindkét függvénnyel 120, 1, 1, illetve egy több mint 450 000 jegyű szám (az egész számok pontossága korlátlan). Érdemes kipróbálni, tapasztalható-e lényeges különbség a két függvény futási ideje között.

A jobbrekurzív kódot a modern értelmező- és fordítóprogramok nagyon hatékonyan, iteratív processzként valósítják meg: a hívás nem foglal újabb veremhelyet. A jobbrekurzió manapság főleg olyan esetekben indokolt, amikor két vagy több processz üzenetet küld egymásnak, és végtelen jobbrekurzív hívásban várnak a válaszüzenetre (lásd Az Elixir nyelv).

Balrekurzió

Balrekurziónak (fejrekurziónak, angolul head recursion) nevezzük, ha a rekurzív hívás egy klóz első és egyetlen rekurzív hívása, azaz a rekurzív hívás előtt nem végzünk semmilyen műveletet. A különbség jól látszik, ha egy függvény a rekurzív hívás előtt vagy után ír ki valamit: a jobbrekurzív változat a hívás előtt írja ki a soron következő számot, a balrekurzív a hívás után, a visszatérés során. A két változatot a fejezet végi upto_by_3 feladat mutatja be.

Klózsorrend és hatékonyság

Egy rekurzív adatszerkezet feldolgozására legalább két, esetleg több klózt írunk. Közöttük vannak olyanok, amelyekre az adatszerkezet jellegzetessége miatt csak egyszer vagy csak nagyon ritkán kerül sor, másokra gyakrabban. Ilyen például az üres és a nem üres lista esete: az üres listát feldolgozó klóz kiértékelésére csak egyszer kerül sor, a nem üres listát feldolgozó klózt a lista hosszától függően akár nagyon sokszor hívjuk.

A kurzus ajánlása: az algoritmus hatékonyságát javítja, ha

• egy függvény klózai kölcsönösen kizárják egymást, és
• közülük a gyakrabban hívott(ak) megelőzi(k) a ritkábban hívott(ak)at:

def fun([x|xs])...
def fun([])...

Az App3.app/2 második klóza illeszkedik az üres listára; a rekurzió során erre csak egyszer kerül sor, ezért ez észszerű döntésnek tűnik. Az App4.app/2 a két klózt fordított sorrendben tartalmazza. Érdemes megmérni, van-e észrevehető különbség a futási időben egy 25 millió elemű listán:

defmodule App4 do
  @spec app(xs :: [integer()], ys :: [integer()]) :: zs :: [integer()]
  # xs és ys listák összefűzöttje zs
  def app([], ys),     do: ys
  def app([x|xs], ys), do: [x|app(xs, ys)]
end

App4.app(Range.to_list(1..25_000_000), [])
:ok

App3.app(Range.to_list(1..25_000_000), [])
:ok

Mérések: egészlista összege háromféleképpen

Az egészlista összegét kiszámoló Sum modulnak (lásd Projektek, mérés, típusellenőrzés) három változata van: a sum1 első, a sum2 második klóza illeszkedik az üres listára, a sum3 pedig egy jobbrekurzív segédfüggvényt hív meg. Van-e különbség a hatékonyságukban?

defmodule Sum do

  @spec sum1(xs::[integer()]) :: sum::integer()
  # xs elemeinek összege sum
  # üres listára az első klóz illeszkedik
  def sum1([]), do: 0
  def sum1([x|xs]), do: x + sum1(xs)

  # üres listára a második klóz illeszkedik
  def sum2([x|xs]), do: x + sum2(xs)
  def sum2([]), do: 0

  # jobbrekurzív
  def sum3(xs), do: sumi(xs, 0)

  defp sumi([x|xs], sum), do: sumi(xs, sum+x)
  defp sumi([], sum), do: sum

end

1..1000 |> Range.to_list() |> Sum.sum1() |> IO.inspect()
1..1000 |> Range.to_list() |> Sum.sum2() |> IO.inspect()
1..1000 |> Range.to_list() |> Sum.sum3() |> IO.inspect()

Mindhárom 500500-at ír ki. A gyakorló notebook mindhármat egy 90 millió elemű listára is lefuttatja:

1..90_000_000 |> Range.to_list() |> Sum.sum1() |> IO.inspect()
1..90_000_000 |> Range.to_list() |> Sum.sum2() |> IO.inspect()
1..90_000_000 |> Range.to_list() |> Sum.sum3() |> IO.inspect()

A Benchee-mérés egy 10 000 elemű listán (1..10_000 |> Enum.to_list |> Sum.sum1() stb.):

Benchee.run(
  %{
    "sum1 ([] az 1. klozban)"  => fn -> 1..10_000 |> Enum.to_list |> Sum.sum1() end,
    "sum2 ([] a 2. klozban)"  => fn -> 1..10_000 |> Enum.to_list |> Sum.sum2() end,
    "sum3 (iterativ, [] a 2. klozban)"  => fn -> 1..10_000 |> Enum.to_list |> Sum.sum3() end
  }# , profile_after: true
)
:ok

Az előadás diáján közölt eredmény (mix run-nal, Elixir 1.18.4, Erlang 28.0.1, Intel i5-8365U; a zárójeles megjegyzések az előadó kiegészítései):

Name           ips        average  deviation         median         99th %
sum3       16.26 K       61.50 µs    ±16.25%       63.65 µs       79.93 µs
sum2        8.87 K      112.80 µs    ±18.45%       97.88 µs      175.92 µs
sum1        8.26 K      121.01 µs    ±18.40%      105.16 µs      187.74 µs

Comparison:
sum3       16.26 K (2. klóz illeszkedik az üres listára a jobbrekurzív segédfüggvényben)
sum2        8.87 K - 1.83x slower +51.30 µs (2. klóz illeszkedik az üres listára)
sum1        8.26 K - 1.97x slower +59.52 µs (1. klóz illeszkedik az üres listára)

Az első előadás segédanyagában (Livebookban, ugyanazon a gépen) mért eredmény:

Name                                       ips        average  deviation         median         99th %
sum3 (iterativ, [] a 2. klozban)       11.60 K       86.22 μs    ±16.11%       82.37 μs      150.53 μs
sum1 ([] az 1. klozban)                 7.54 K      132.56 μs    ±22.29%      126.42 μs      230.17 μs
sum2 ([] a 2. klozban)                  6.73 K      148.58 μs    ±15.46%      136.23 μs      204.25 μs

Comparison: 
sum3 (iterativ, [] a 2. klozban)       11.60 K
sum1 ([] az 1. klozban)                 7.54 K - 1.54x slower +46.33 μs
sum2 ([] a 2. klozban)                  6.73 K - 1.72x slower +62.36 μs

Az első gyakorlat nth feladatánál (lásd lent) egy 100 001 elemű lista első, középső és utolsó elemét kérjük el, egyszer az üres listát utolsóként (EmptyLast), egyszer elsőként (EmptyFirst) kezelő klózsorrenddel:

Name                           ips        average  deviation         median         99th %
firstElemEmptyFirst      1745.97 K        0.57 μs    ±98.93%        1.02 μs        2.05 μs
firstElemEmptyLast       1724.38 K        0.58 μs   ±100.87%        1.02 μs        2.05 μs
middleElemEmptyLast         6.32 K      158.12 μs    ±41.63%      102.40 μs      307.20 μs
middleElemEmptyFirst        6.28 K      159.34 μs    ±50.58%      102.40 μs      307.20 μs
lastElemEmptyLast           3.16 K      316.78 μs    ±30.90%      307.20 μs      614.40 μs
lastElemEmptyFirst          3.08 K      324.93 μs    ±31.75%      307.20 μs      614.40 μs

A két klózsorrend között mért különbségek kicsik és nem következetesek: a diáin a sum2 a gyorsabb, a segédanyagban a sum1, az nth-nél pedig 1–3% az eltérés. Egyértelmű nyereséget a jobbrekurzió hoz: a sum3 mindkét mérésben másfél-kétszer gyorsabb. A futási idő a lista hosszával arányosan nő: az utolsó elem elérése kétszer annyi ideig tart, mint a középsőé.

Hibajelzés: Erlang- és Elixir-stílus

Gyakran előfordul, hogy bizonyos listákon bizonyos műveleteket nem lehet elvégezni. Egy üres listának például egyetlen eleme sincs, bármelyik elemét is kérjük, nincs mit eredményül adni.

Ilyenkor dönthetünk úgy, hogy az adott műveletet üres listára nem értelmezzük, és a hiba jelzését a rendszerre bízzuk (a hívás például FunctionClauseError hibával leáll). Ha úgy döntünk, hogy a helyes eredmény mellett a hibát is jelezzük, ezt hagyományosan kétféle stílusban tehetjük meg:

• Erlang-stílusban a visszatérési érték típusa {:ok, any()} | :error: siker esetén a visszatérési érték egy {:ok, value} pár, ahol value a visszaadott, any() típusú érték, meghiúsulás esetén pedig az :error atom.
• Elixir-stílusban a visszatérési érték típusa any() | nil: siker esetén maga az any() típusú value, meghiúsulás esetén a nil atom.

Mindhárom változatra példa a lenti 5. feladat (Last, LastEx, LastEr).

Gyakorló feladatok

Az alábbi feladatok megoldására ne használja az azonos vagy hasonló feladatokat megoldó könyvtári függvényeket a Kernel, List, Enum és más modulokból, pl. hd, tl, first, last, at, length, split, slice! Gyakorlásképpen saját, ahol kell, rekurzív függvénydefiníciókat írjon. A specifikációs kódrészletek a megírandó függvény keretét (modul, típusspecifikáció, fejkomment) és néhány teszthívást tartalmaznak; a ... helyére kell a megoldást írni.

1. Lista feje

Írjon függvényt egy lista fejének (első elemének) visszaadására! Ha a lista üres, Elixir-stílusban jelezze, azaz a nil atomot adja eredményül. Tipp: az első klóz a legalább egyelemű listára, a második az üres listára illeszkedjen.

defmodule Head do
  @spec hd(xs :: [any()]) :: r :: any() | nil
  # Ha xs nem üres, x az xs lista feje, egyébként nil
  def hd(...), do:
  ...
end
IO.puts(Head.hd([]) == nil)
IO.puts(Head.hd(Range.to_list(1..5)) == 1)
IO.puts(Head.hd(~c"almárium") == ?a)

defmodule Head do
  @spec hd(xs :: [any()]) :: r :: any() | nil
  # Ha xs nem üres, x az xs lista feje, egyébként nil
  def hd([x|_]), do: x
  def hd([]), do: nil
end

2. Lista farka

Írjon függvényt egy lista farkának (az első eleme utáni részlistájának) visszaadására! Ha a lista üres, Elixir-stílusban jelezze, azaz a nil atomot adja eredményül. Tipp: az első klóz a legalább egyelemű listára, a második az üres listára illeszkedjen.

defmodule Tail do
  @spec tl(xs: [any()]) :: ts :: [any()] | nil
  # Az xs lista farka ts
  def tl(...), do:
  ...
end
IO.puts(Tail.tl([]) == nil)
IO.puts(Tail.tl(Range.to_list(1..5)) == [2,3,4,5])
IO.puts(Tail.tl(~c"almárium") == ~c"lmárium")

defmodule Tail do
  @spec tl(xs: [any()]) :: ts :: [any()] | nil
  # Az xs lista farka ts
  def tl([_|xs]), do: xs
  def tl([]), do: nil
end

3. Lista n-edik eleme

Írjon rekurzív függvényt egy lista n-edik elemének visszaadására! (A lista indexelése 0-tól indul.) Ha a lista n-nél rövidebb, Elixir-stílusban jelezze, azaz a nil atomot adja eredményül. Tipp: három klózt kell írnia: egyet az üres listára, egyet a megtalált elem visszaadására, egyet pedig arra, hogy rekurzív hívással folytassa a keresést.

defmodule Nth do
  @spec nth(xs :: [any()], n :: integer()) :: r :: any() | nil
  # Ha xs elég hosszú, r az xs n-edik eleme; egyébként nil (indexelés 0-tól)
  def nth(..., n), do:
  ...
end
IO.puts(Nth.nth([], 5) == nil)
IO.puts(Nth.nth(Range.to_list(1..5), 4) == 5)
IO.puts(Nth.nth(Range.to_list(1..5), 5) == nil)
IO.puts(Nth.nth(~c"almárium", 3) == ?á)
IO.puts(Nth.nth(~c"almárium", -3) == nil)

A benchee modul segítségével hasonlítsa össze a futási időket egy hosszú lista első, középső és utolsó elemének elérése esetén, olyan klózsorrendekkel, amikor az első, illetve amikor az utolsó klóz illeszkedik az üres listára!

defmodule Nth do
  @spec nth(xs :: [any()], n :: integer()) :: r :: any() | nil
  # Ha xs elég hosszú, r az xs n-edik eleme; egyébként nil (indexelés 0-tól)
  def nth([x|_], 0), do: x
  def nth([_|xs], n), do: nth(xs, n-1)
  def nth([], _), do: nil
end

defmodule NthEmptyFirst do
  @spec nth(xs :: [any()], n :: integer()) :: r :: any() | nil
  # Ha xs elég hosszú, r az xs n-edik eleme; egyébként nil (indexelés 0-tól)
  def nth([], _), do: nil
  def nth([x|_], 0), do: x
  def nth([_|xs], n), do: nth(xs, n-1)
end
IO.puts(NthEmptyFirst.nth([], 5) == nil)
IO.puts(NthEmptyFirst.nth(Range.to_list(1..5), 4) == 5)
IO.puts(NthEmptyFirst.nth(Range.to_list(1..5), 5) == nil)
IO.puts(NthEmptyFirst.nth(~c"almárium", 3) == ?á)
IO.puts(NthEmptyFirst.nth(~c"almárium", -3) == nil)

l = Range.to_list(0..100_000)
Benchee.run(%{
        "firstElemEmptyLast" => fn -> Nth.nth(l, 0) end,
        "middleElemEmptyLast" => fn -> Nth.nth(l, 50_000) end,
        "lastElemEmptyLast" => fn -> Nth.nth(l, 100_000) end,
        "firstElemEmptyFirst" => fn -> NthEmptyFirst.nth(l, 0) end,
        "middleElemEmptyFirst" => fn -> NthEmptyFirst.nth(l, 50_000) end,
        "lastElemEmptyFirst" => fn -> NthEmptyFirst.nth(l, 100_000) end
    }
)