Elixir

**Elixir** – funkcinė programavimo kalba, vykdoma BEAM virtualioje mašinoje. Elixir sukurtas Erlang programavimo kalbos pagrindu ir turi tas pačias abstrakcijas, skirtas kurti plačiai naudojamoms, atsparioms gedimams programoms. Elixir taip pat siūlo įrankius bei savitą dizainą, kurį kompiliavimo metu palaiko meta programavimas makrokomandomis ir polimorfizmas.

Elixir programuotojų bendruomenė organizuoja kasmetinius renginius JAV, Europoje ir Japonijoje, taip pat mažesnius renginius vietinėse bendruomenėse. Šiandien Lietuvoje Elixir bendruomenės nėra, ir programavimo kalba nėra plačiai naudojama.

## Istorija
Elixir programavimo kalbą 2012 metais sukūrė brazilas Žozė Valimas (*José Valim*) kaip tyrinėjimo ir plėtros projektą. Jo tikslas buvo sukurti platesnio pobūdžio bei produktyvumo įrankį Erlang virtualioje mašinoje, tuo pačiu palaikant Erlang ekosistemą.

Elixir tinkama labai didelėms svetainėms bei aplikacijoms. Ji naudoja Erlang, Ruby, Clojure programavimo kalbų ypatybes, tam, kad būtų galima sukurti lygiagrečiai veikiančią (), bet mažo uždelsimo () programavimo kalbą. Ji sukurta didelių duomenų kiekių apdorojimui. Elixir taip pat naudojama telekomunikacijos, elektroninės prekybos, finansų srityse.

2021 m. Numerical Elixir paskelbė sieksianti dirbtinį intelektą, neuroninius tinklus, grafinių plokščių kompiliavimą, duomenų apdorojimą įtraukti į Elixir ekosistemą.

## Versijavimas
Kiekviena mažoji versija (*minor version*) palaiko specifinį kiekį Erlang/OTP versijų. Dabartinė stabili versija yra 1.17.13, išleista 2024 m. rugsėjo 18 d.

## Pavyzdžiai
Šie pavyzdžiai gali buti nuskaitomi `iex` aplinkoje (*shell*) arba išsaugoti `.ex` `.iex` formato failuose ir paleisti per terminalą su komanda `elixir <failo_pavadinimas>`

Klasikinis "Hello world! ":


```iex
iex> IO.puts("Hello World! ")
Hello World!
```


Pipe operatorius:

```iex
iex> „Elixir“ |> String.graphemes() |> Enum.frequencies()
%{„E“ => 1, „i“ => 2, „l“ => 1, „r“ => 1, „x“ => 1}

iex> %{values: 1..5} |> Map.get(:values) |> Enum.map(& &1 * 2)
[2, 4, 6, 8, 10]

iex> |> Enum.sum()
30
```

Modelio sutapatinimas (eng. pattern matching):

```iex
iex> %{left: x} = %{left: 5, right: 8}
iex> x
5

iex> {:ok, [_ | rest]} = {:ok, [1, 2, 3]}
iex> rest
[2, 3]
```

```iex
iex> case File.read(„path/to/file“) do
iex> {:ok, contents} -> IO.puts(„found file: #{contents}“)
iex> {:error, reason} -> IO.puts(„missing file: #{reason}“)
iex> end
```


Sąrašas:

```iex
iex> for n <- 1..5, rem(n, 2) == 1, do: n*n
[1, 9, 25]
```


Asinchroninis failų nuskaitymas:

```elixir
1..5
|> Task.async_stream(&File.read! („#{&1}.txt“))
|> Stream.filter(fn {:ok, contents} -> String.trim(contents) != "" end)
|> Enum.join(„\n“)
```


Tos pačios funkcijos aprašymas. Vykdoma tik ta, kuri atitinka sąlygą:

```elixir
def fib(n) when n in [0, 1], do: n
def fib(n), do: fib(n-2) + fib(n-1)
```


Reliacinės duomenų bazės naudojant **Ecto** biblioteką:

```elixir
schema „weather“ do
  field :city 
  field :temp_lo, :integer
  field :temp_hi, :integer
  field :prcp,    :float, default: 0.0
end

Weather |> where(city: „Kraków“) |> order_by(:temp_lo) |> limit(10) |> Repo.all
```


Paeiliui kuriami 1000 skirtingų procesų:

```elixir
for num <- 1..1000, do: spawn fn -> IO.puts(„#{num * 2}“) end
```


Asinchroniškai vykdoma užduotis:

```elixir
task = Task.async fn -> perform_complex_action() end
other_time_consuming_action()
Task.await task
```


## Išnašos