#{text}
" end) - - # => ["foo
", "bar
", "hello
", "hexlet
"] - ``` - - `Stream.unfold` можно представить, как функцию, обратную *свертке* (fold или reduce). Если fold сворачивает список в одиночное значение, то unfold наоборот, из одиночного значения разворачивает список. - - Функция принимает на вход начальное значение и разворачивающую функцию. Разворачивающая функция принимает на вход текущее состояние, и возвращает кортеж из двух значений. Первый элемент кортежа, это то, что становится очередным элементом списка. Второй элемент кортежа, это новое состояние, которое передается в разворачивающую функцию на следующем шаге. - - Рассмотрим пример с числами Фибоначчи: - - ```elixir - initial_state = {0, 1} - - unfolder = fn({val1, val2}) -> - curr_val = val1 - new_state = {val2, val1 + val2} - {curr_val, new_state} - end - - Stream.unfold(initial_state, unfolder) |> Enum.take(20) - # => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] - ``` - -instructions: | - - Создайте функцию `generate`, которая случайно генерирует бесконечную последовательность чисел от 1 до 20 и берет `n` элементов от этой коллекции: - - ```elixir - Solution.generate(5) - # => [2, 10, 20, 12, 11] - Solution.generate(2) - # => [7, 14] - Solution.generate(20) - # => [2, 9, 18, 1, 3, 16, 1, 1, 20, 20, 9, 11, 10, 14, 10, 15, 3, 3, 10, 8] - ``` - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Stream.html) diff --git a/modules/40-collections/50-stream/en/data.yml b/modules/40-collections/50-stream/en/data.yml index e130ff4..0cc63ea 100644 --- a/modules/40-collections/50-stream/en/data.yml +++ b/modules/40-collections/50-stream/en/data.yml @@ -1,2 +1,3 @@ +--- name: Streams tips: [] diff --git a/modules/40-collections/50-stream/ru/data.yml b/modules/40-collections/50-stream/ru/data.yml index fde1903..ed6d4c7 100644 --- a/modules/40-collections/50-stream/ru/data.yml +++ b/modules/40-collections/50-stream/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Стримы tips: - | diff --git a/modules/45-structs/10-struct-intro/description.en.yml b/modules/45-structs/10-struct-intro/description.en.yml deleted file mode 100644 index 1362aeb..0000000 --- a/modules/45-structs/10-struct-intro/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Structs intro -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/45-structs/10-struct-intro/description.ru.yml b/modules/45-structs/10-struct-intro/description.ru.yml deleted file mode 100644 index 42bbfab..0000000 --- a/modules/45-structs/10-struct-intro/description.ru.yml +++ /dev/null @@ -1,156 +0,0 @@ ---- -name: Введение в структуры -theory: | - - Для моделирования данных, которые лучше отражает предметную область, используют структуры. - - Структуры по сути словари, но с некоторыми особенностями. Структуры проверяются на уровне компиляции, в них можно задать значения по умолчанию и структурам недоступны протоколы для словарей, например протоколы `Enum`. Протоколы рассмотрим чуть дальше, а сейчас изучим структуры: - - ```elixir - defmodule Counter do - defstruct state: 0 - end - - my_counter = %Counter{} - %Counter{state: 0} - ``` - - В примере мы объявили модуль `Counter` и в нем объявили, что этот модуль является структурой с полем `state`, которое по умолчанию равно `0`. Затем мы связали `my_counter` с ранее объявленной структурой. Еще мы можем объявить поля без значения по умолчанию: - - ```elixir - defmodule Counter do - defstruct [:current, initial: 0, hello: "world"] - end - - defmodule Counter2 do - defstruct current: nil, initial: 0, hello: "world" - end - - my_counter = %Counter{} - # => %Counter{current: nil, initial: 0, hello: "world"} - my_second_counter = %Counter2{} - # => %Counter2{current: nil, initial: 0, hello: "world"}} - ``` - - Теперь рассмотрим, как работать с полями структур: - - ```elixir - defmodule User do - defstruct age: 0, name: "John" - end - - john = %User{age: 20} - john.age - # => 20 - - john.name - # => "John" - - alice = %{john | name: "Alice"} - alice.name - # => "Alice" - - jane = %{alice | other_field: "some"} - # => ** (KeyError) key :other_field not found in: %User{age: 20, name: "Alice"} - # => (stdlib 4.3.1.1) :maps.update(:other_field, "some", %User{age: 20, name: "Alice"}) - ``` - - Используя синтаксис модификации `|`, виртуальная машина заранее знает, что структура имеет фиксированное количество полей и не дает добавлять новые, только менять заранее объявленные. Интересный момент, что структуры можно использовать в паттерн-матчинге: - - ```elixir - defmodule Pet do - defstruct name: "Barkley" - end - - defmodule User do - defstruct name: "John" - end - - defmodule Example do - def print_name(%User{name: name} = user) do - "Hello, human #{name}" - end - - def print_name(%Pet{name: name} = pet) do - "Hello, pet #{name}" - end - end - - pet = %Pet{} - user = %User{} - - Example.print_name(pet) - # => "Hello, pet Barkley" - Example.print_name(user) - # => "Hello, human John" - ``` - - Благодаря паттерн-матчингу мы добились полиморфного поведения функции. - - Так как структуры не используют протоколы словарей, то и доступ к полю через `[]` становится недоступным: - - ```elixir - defmodule User do - defstruct age: 0, name: "John" - end - - user = %User{} - # => %User{age: 0, name: "John"} - - user.name - # => "John" - - user[:name] - # => ** (UndefinedFunctionError) function User.fetch/2 is undefined (User does not implement the Access behaviour. If you are using get_in/put_in/update_in, you can specify the field to be accessed using Access.key!/1) - # => User.fetch(%User{age: 0, name: "John"}, :name) - # => (elixir 1.15.0) lib/access.ex:305: Access.get/3 - # => iex:201: (file) - - Map.get(user, :name) - # => "John" - ``` - - Еще с помощью атрибута `enforce_keys` можно добавить проверку на инициализацию данных по ключу при создании структуры: - - ```elixir - defmodule User do - @enforce_keys [:name, :age] - defstruct [:name, :age] - end - - %User{} - # => ** (ArgumentError) the following keys must also be given when building struct User: [:name, :age] - # => expanding struct: User.__struct__/1 - # => iex:204: (file) - - %User{name: "John"} - # => ** (ArgumentError) the following keys must also be given when building struct User: [:age] - # => expanding struct: User.__struct__/1 - # => iex:205: (file) - - %User{name: "John", age: 20} - # => %User{name: "John", age: 20} - ``` - - Такая проверка работает только во время компиляции и только при создании структуры. Проверка не будет запускаться при изменении данных по ключу. - -instructions: | - - Создайте функцию `calculate_stats`, которая подсчитывает, сколько в списке людей и питомцев: - - ```elixir - users_and_pets = [%User{}, %User{}, %Pet{}] - - Solution.calculate_stats(users_and_pets) - # => %{humans: 2, pets: 1} - - Solution.calculate_stats([]) - # => %{humans: 0, pets: 0} - - only_pets = [%Pet{}, %Pet{}, %Pet{}] - # => %{humans: 0, pets: 3} - ``` - - Обратите внимание, что структуры в модуле заранее определены. - -tips: [] diff --git a/modules/45-structs/10-struct-intro/en/data.yml b/modules/45-structs/10-struct-intro/en/data.yml index 2a1e307..49df246 100644 --- a/modules/45-structs/10-struct-intro/en/data.yml +++ b/modules/45-structs/10-struct-intro/en/data.yml @@ -1,2 +1,3 @@ +--- name: Structs intro tips: [] diff --git a/modules/45-structs/10-struct-intro/ru/data.yml b/modules/45-structs/10-struct-intro/ru/data.yml index 64f4617..11d7c84 100644 --- a/modules/45-structs/10-struct-intro/ru/data.yml +++ b/modules/45-structs/10-struct-intro/ru/data.yml @@ -1,2 +1,3 @@ +--- name: Введение в структуры tips: [] diff --git a/modules/45-structs/20-typespecs/description.en.yml b/modules/45-structs/20-typespecs/description.en.yml deleted file mode 100644 index 8ebc2f4..0000000 --- a/modules/45-structs/20-typespecs/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Typespecs -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/45-structs/20-typespecs/description.ru.yml b/modules/45-structs/20-typespecs/description.ru.yml deleted file mode 100644 index 15a5242..0000000 --- a/modules/45-structs/20-typespecs/description.ru.yml +++ /dev/null @@ -1,109 +0,0 @@ ---- -name: Описание типов -theory: | - - Для продолжения обсуждения `протоколов` и `поведения`, нам нужно ознакомиться с типизацией в Elixir. - - Elixir - динамически типизированный язык, поэтому все типы в Elixir проверяются во время выполнения. Тем не менее, Elixir поставляется со *спецификациями*, которые представляют собой нотацию, используемую для: - - - объявления типизированных сигнатур функций (также называемых спецификациями); - - объявления пользовательских типов. - - Спецификации полезны для документации кода и статического анализа кода, например, Dialyzer в Erlang или Dialyxir для Elixir. - - Elixir предоставляет множество встроенных типов, таких как `integer` или `pid`, которые используются для документирования сигнатур функций. Например, функция round/1, которая округляет число до ближайшего целого. Как видно из документации, [типизированная сигнатура функции round/1](https://hexdocs.pm/elixir/Kernel.html#round/1) имеет вид: - - ```elixir - round(number()) :: integer() - ``` - - Синтаксис состоит в том, что слева от :: указывается функция и ее входные данные, а справа - тип возвращаемого значения. Типы могут не содержать круглых скобок. - - В коде спецификации функций записываются с помощью атрибута `@spec`, который располагается перед определением функции. В спецификациях могут описываться как публичные, так и частные функции. Имя функции и количество аргументов, используемых в атрибуте `@spec`, должны соответствовать описываемой функции: - - ```elixir - defmodule Example do - - @spec substract(integer, integer) :: integer - def substract(first, second) do - first - second - end - - @spec inc_list(list(integer)) :: list(integer) - def inc_list(numbers) do - numbers |> Enum.map(&(&1 + 1)) - end - - @spec magic(boolean) :: integer | String.t - def magic(do_magic \\ true) do - if do_magic, do: 2, else: "hello" - end - end - ``` - - Определение пользовательских типов может помочь передать замысел вашего кода и повысить его читаемость. Пользовательские типы могут быть определены в модулях с помощью атрибута `@type`. - - Примером реализации пользовательского типа является предоставление более описательного псевдонима существующего типа. Например, определение `year` в качестве типа делает спецификации функций более описательными, чем если бы они использовали просто `integer`: - - ```elixir - defmodule User do - @typedoc """ - A 4 digit year, e.g. 1984 - """ - @type year :: integer - - @spec current_age(year) :: integer - def current_age(year_of_birth), do: # implementation - end - ``` - - Пользовательские типы могут быть и сложнее, например: - - ```elixir - @type error_map :: %{ - message: String.t, - line_number: integer - } - ``` - - Пользовательские типы можно использовать внутри других модулей: - - ```elixir - defmodule Errors do - @type error_map :: %{ - message: String.t, - line_number: integer - } - end - - defmodule Magic do - - @spec do_magic(integer) :: integer | Errors.error_map - def do_magic(a) when is_integer(a) do - Enum.random(1..100) - end - - def do_magic(_) do - %{message: "Incorrect argument", line_number: Enum.random(1..100)} - end - end - ``` - - -instructions: | - - Создайте функцию `generate_pets`, в которую передается количество питомцев, список которых нужно сгенерировать с именем `Barkley x`, где `x` - идентификатор питомца (отсчет идет с нуля). Модуль `Pet` описан заранее. Опишите спецификацию созданной функции: - - ```elixir - Solution.generate_pets(2) - # => [%Pet{name: "Barkley 0"}, %Pet{name: "Barkley 1"}] - - Solution.generate_pets(-2) - # => [] - ``` - -tips: - - | - [Список типов](https://hexdocs.pm/elixir/typespecs.html#basic-types) - - | - [Dyalyzer для Elixir](https://github.com/jeremyjh/dialyxir) diff --git a/modules/45-structs/20-typespecs/en/data.yml b/modules/45-structs/20-typespecs/en/data.yml index 41c3fcb..8480cff 100644 --- a/modules/45-structs/20-typespecs/en/data.yml +++ b/modules/45-structs/20-typespecs/en/data.yml @@ -1,2 +1,3 @@ +--- name: Typespecs tips: [] diff --git a/modules/45-structs/20-typespecs/ru/data.yml b/modules/45-structs/20-typespecs/ru/data.yml index 2d5b893..691f8d2 100644 --- a/modules/45-structs/20-typespecs/ru/data.yml +++ b/modules/45-structs/20-typespecs/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Описание типов tips: - | diff --git a/modules/45-structs/30-behaviour/description.en.yml b/modules/45-structs/30-behaviour/description.en.yml deleted file mode 100644 index c3c34a2..0000000 --- a/modules/45-structs/30-behaviour/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Behaviours -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/45-structs/30-behaviour/description.ru.yml b/modules/45-structs/30-behaviour/description.ru.yml deleted file mode 100644 index bcb4cab..0000000 --- a/modules/45-structs/30-behaviour/description.ru.yml +++ /dev/null @@ -1,125 +0,0 @@ ---- -name: Поведение -theory: | - - Многие модули используют один и тот же общедоступный API. [Рассмотрим Plug](https://hexdocs.pm/plug/readme.html), который, как сказано в его описании, является спецификацией для композитных (composable) модулей в веб-приложениях. Каждый модуль, *поведение* которого соответствует Plug, должен реализовать как минимум две публичные функции: `init/1` и `call/2`. - - Поведения (behaviour) предоставляют возможность: - - определить набор функций, которые должны быть реализованы модулем; - - гарантировать, что модуль реализует все функции из этого набора. - - По сути, поведение это как интерфейсы в объектно-ориентированных языках типа Java: набор сигнатур функций, которые должен реализовать модуль. В отличие от протоколов, которые мы рассмотрим в следующем модуле, поведение не зависит от типа данных. - - Теперь определим поведение на примере. Допустим, мы хотим реализовать несколько парсеров, каждый из которых будет разбирать структурированные данные: например, парсер JSON и парсер MessagePack. Каждый из этих двух парсеров будет вести себя одинаково: оба будут предоставлять функцию `parse/1` и функцию `extensions/0`. Функция `parse/1` будет возвращать Elixir-представление структурированных данных, а функция `extensions/0` - список расширений файлов, используются для каждого типа данных (например, .json для файлов JSON). - - ```elixir - defmodule Parser do - @doc """ - Parses a string. - """ - @callback parse(String.t) :: {:ok, any} | {:error, atom} - - @doc """ - Lists all supported file extensions. - """ - @callback extensions() :: [String.t] - end - ``` - - Модули, использующие поведение `Parser`, должны реализовать все функции, определенные с помощью атрибута @callback. Как видно, @callback ожидает не только имя функции, но и спецификацию функции, подобную той, что используется с атрибутом @spec, рассмотренные в прошлом модуле. Также обратите внимание, что для представления разобранного значения используется тип `any`. - - Теперь реализуем описанное поведение: - - ```elixir - defmodule JSONParser do - @behaviour Parser - - @impl Parser - def parse(str), do: {:ok, "parsed json " <> str} - - @impl Parser - def extensions, do: [".json"] - end - - defmodule CSVParser do - @behaviour Parser - - @impl Parser - def parse(str), do: {:ok, "parsed csv " <> str} - - @impl Parser - def extensions, do: [".csv"] - end - ``` - - Если модуль, реализующий заданное поведение, не реализует одну из функций обратного вызова (callback), требуемых этим поведением, то будет выведено предупреждение на этапе компиляции. - - Кроме того, с помощью `@impl` можно убедиться в том, что вы реализуете правильные функции обратного вызова из заданного поведения в явном виде. Например, следующий парсер реализует и `parse`, и `extensions`. Однако, из-за опечатки, BADParser реализует `parse/0` вместо `parse/1`: - - ```elixir - defmodule BADParser do - @behaviour Parser - - @impl Parser - def parse, do: {:ok, "oh no"} - - @impl Parser - def extensions, do: ["boom"] - end - ``` - - При компиляции этого кода, компилятор выдает предупреждение о том, что реализован `parse/0`, а не `parse/1`. - - Поведения полезны тем, что можно передавать модули в качестве аргументов и затем вызывать любую из функций, указанных в поведении. Например, у нас может быть функция, которая получает имя файла, и на основе его расширения вызывает соответствующий парсер: - - ```elixir - @spec parse_file(Path.t(), [module()]) :: {:ok, any} | {:error, atom} - def parse_file(filename, parsers) do - with {:ok, ext} <- parse_extension(filename), - {:ok, parser} <- find_parser(ext, parsers), - {:ok, contents} <- File.read(filename) do - parser.parse(contents) - end - end - - defp parse_extension(filename) do - if ext = Path.extname(filename) do - {:ok, ext} - else - {:error, :no_extension} - end - end - - defp find_parser(ext, parsers) do - if parser = Enum.find(parsers, fn parser -> ext in parser.extensions() end) do - {:ok, parser} - else - {:error, :no_matching_parser} - end - end - ``` - - Можно вызвать необходимый парсер напрямую или сделать словарь, где ключем будет нужное расширение файла, а значением нужный модуль парсера, однако *поведение* в этом дает чуть больше гарантий, что функции модулей реализованы соответствующим образом. - -instructions: | - - Реализуйте парсер, который читает текст (расширение `.txt`) и построчно читает его (разделитель `\n`). Если текст пустой, верните ошибку: - - ```elixir - TextParser.extensions() - # => [".txt"] - - text = "hello\nworld!" - TextParser.parse(text) - # => {:ok, ["hello", "world!"]} - - text = "" - TextParser.parse(text) - # => {:error, :no_text} - ``` - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Module.html#module-behaviour) - - | - [Документация Plug](https://hexdocs.pm/plug/readme.html) diff --git a/modules/45-structs/30-behaviour/en/data.yml b/modules/45-structs/30-behaviour/en/data.yml index 7b0b598..a1446ec 100644 --- a/modules/45-structs/30-behaviour/en/data.yml +++ b/modules/45-structs/30-behaviour/en/data.yml @@ -1,2 +1,3 @@ +--- name: Behaviours tips: [] diff --git a/modules/45-structs/30-behaviour/ru/data.yml b/modules/45-structs/30-behaviour/ru/data.yml index 805f297..d630460 100644 --- a/modules/45-structs/30-behaviour/ru/data.yml +++ b/modules/45-structs/30-behaviour/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Поведение tips: - > diff --git a/modules/45-structs/40-protocols/description.en.yml b/modules/45-structs/40-protocols/description.en.yml deleted file mode 100644 index bf544b4..0000000 --- a/modules/45-structs/40-protocols/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Protocols -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/45-structs/40-protocols/description.ru.yml b/modules/45-structs/40-protocols/description.ru.yml deleted file mode 100644 index c668490..0000000 --- a/modules/45-structs/40-protocols/description.ru.yml +++ /dev/null @@ -1,115 +0,0 @@ ---- -name: Протоколы -theory: | - - С помощью протоколов в Elixir реализуется *полиморфное поведение* в зависимости от типа данных. Начнем с примера реализации полиморфного поведения с помощью сопоставления с образцом: - - ```elixir - defmodule Typer do - def type(value) when is_binary(value), do: "string" - def type(value) when is_integer(value), do: "integer" - def type(value) when is_list(value), do: "array" - def type(value) when is_map(value), do: "hash" - # ... other implementations - end - - Typer.type(2) - # => "integer" - - Typer.type([]) - # => "array" - - Typer.type(%{}) - # => "hash" - ``` - - С этим кодом не будет проблем, если он используется в рамках одного приложения в небольшом количестве мест. Однако, поддерживать такой код станет заметно сложнее, если он превратится в *зависимость* для нескольких приложений (см. expression problem), так как нет простых способов расширять функциональность такого модуля. - - Как раз для таких случаев и используются *протоколы*. По сути протоколы позволяют выполнять диспетчеризацию на *любом* типе данных, который реализуют соответствующий протокол. Важно, что протоколы могут быть реализованы в любом месте, где это нужно. Теперь перепишем модуль `Typer`: - - ```elixir - defprotocol Typer do - @spec type(t) :: String.t() - def type(value) - end - - defimpl Typer, for: BitString do - def type(_value), do: "string" - end - - defimpl Typer, for: Integer do - def type(_value), do: "integer" - end - - defimpl Typer, for: List do - def type(_value), do: "array" - end - - defimpl Typer, for: Map do - def type(_value), do: "hash" - end - - Typer.type(2) - # => "integer" - - Typer.type([]) - # => "array" - - Typer.type(%{}) - # => "hash" - ``` - - Мы определили протокол с помощью `defprotocol` - описали в нем функцию со спецификацией. Затем через `defimpl` мы описали реализацию протокола для соответствующих типов данных. - - С помощью протоколов мы получили преимущество. Теперь мы не привязаны к модулю, в котором определили протокол, если нужно добавить реализацию для какого-либо нового типа. Например, реализацию протокола `Typer` мы можем разнести по разным файлам и модулям, а Elixir найдет и вызовет нужную реализацию протокола для описанных нами данных. - - Функции, определенные в протоколе, могут принимать больше одного аргумента, но *диспетчеризация произойдет по первому аргументу*. - - Протоколы можно определить для всех типов Elixir: - - Atom - - BitString - - Float - - Function - - Integer - - List - - Map - - PID - - Port - - Reference - - Tuple - - Помимо встроенных типов, протоколы можно определять для *структур*: - - ```elixir - defmodule User do - defstruct [:name, :age] - end - - defimpl Typer, for: User do - def type(_value), do: "user" - end - - Typer.type(%User{age: 20, name: "John"}) - # => "user" - ``` - -instructions: | - - Определите три структуры `Human`, `Dog` и `Cat` с полем `name`. Затем определите функцию `say_something` для протокола `Teller` для каждого из модулей, которая возвращает строку в зависимости от типа: - - Для Human `Hello, world!` - - Для Cat `Meow, world!` - - Для Dog `Bark, world!` - - ```elixir - Teller.say_something(%Human{name: "John"}) # => "Hello, world!" - Teller.say_something(%Dog{name: "Barkinson"}) # => "Bark, world!" - Teller.say_something(%Cat{name: "Meowington"}) # => "Meow, world!" - ``` - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Protocol.html) - - | - [Про Expression Problem](https://en.wikipedia.org/wiki/Expression_problem) - - | - [Подкаст про Expression Problem](https://soundcloud.com/mimpod/episode_61) diff --git a/modules/45-structs/40-protocols/en/data.yml b/modules/45-structs/40-protocols/en/data.yml index 83119c5..9c45944 100644 --- a/modules/45-structs/40-protocols/en/data.yml +++ b/modules/45-structs/40-protocols/en/data.yml @@ -1,2 +1,3 @@ +--- name: Protocols tips: [] diff --git a/modules/45-structs/40-protocols/ru/data.yml b/modules/45-structs/40-protocols/ru/data.yml index 0a1816c..06ffb3c 100644 --- a/modules/45-structs/40-protocols/ru/data.yml +++ b/modules/45-structs/40-protocols/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Протоколы tips: - | diff --git a/modules/45-structs/50-any-protocols/description.en.yml b/modules/45-structs/50-any-protocols/description.en.yml deleted file mode 100644 index 5593026..0000000 --- a/modules/45-structs/50-any-protocols/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Any protocols -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/45-structs/50-any-protocols/description.ru.yml b/modules/45-structs/50-any-protocols/description.ru.yml deleted file mode 100644 index c675aee..0000000 --- a/modules/45-structs/50-any-protocols/description.ru.yml +++ /dev/null @@ -1,72 +0,0 @@ ---- -name: Общие протоколы -theory: | - - Ручная реализация протоколов для всех типов может быстро стать повторяющейся и утомительной. В таких случаях Elixir предоставляет два варианта: можно явно вывести (derive) реализацию протокола для наших типов или автоматически реализовать протокол для всех типов. В обоих случаях необходимо реализовать протокол для `Any`. - - Опишем явное выведение (derive) протокола из примера `Typer` прошлого модуля: - - ```elixir - defprotocol Typer do - @spec type(t) :: String.t() - def type(value) - end - - defimpl Typer, for: Any do - def type(_value), do: "something" - end - ``` - - Конечно, реализация получилось странной, потому что для любого типа будет возвращаться `something`, однако это учебный пример. Теперь опишем пользователя и явно *выведем* для него протокол: - - ```elixir - defmodule SomeUser do - @derive [Typer] - defstruct [:name, :age] - end - - Typer.type(%SomeUser{}) - # => "something" - ``` - - В другом случае, в протоколе указывается опция `fallback_to_any` и если не будет найден нужный протокол под тип, то будет использована реализация протокола для `Any`: - - ```elixir - defprotocol Typer do - @fallback_to_any true - - def type(value) - end - - defimpl Typer, for: Any do - def type(_value), do: "something new" - end - - defmodule AnotherUser do - defstruct [:name] - end - - Typer.type(%AnotherUser{}) - # => "something new" - ``` - - Как было сказано выше, не всегда реализация протокола для `Any` необходима, так как может не иметь смысла для некоторых типов данных. Например, протокол `Size` имеет смысл для перечислимых типов данных, но не для чисел. Поэтому зачастую выброс ошибки при отсутствии необходимой реализации протокола является ожидаемым поведением. - - Какой выбрать из вариантов между явным выведением (derive) или опцией `fallback_to_any` зависит от ситуации. Тем не менее явное лучше, чем неявное, поэтому зачастую в Elixir библиотеках используется подход с `derive`. - -instructions: | - - Продолжим упражнение из прошлого модуля, теперь опишите структуру `Robot` с явным указанием протокола `Teller` и реализуйте протокол для `Any` который возвращает строку `World!`: - - ```elixir - Teller.say_something(%Human{name: "John"}) # => "Hello, world!" - Teller.say_something(%Dog{name: "Barkinson"}) # => "Bark, world!" - Teller.say_something(%Cat{name: "Meowington"}) # => "Meow, world!" - Teller.say_something(%Robot{name: "Roberto"}) # => "World!" - ``` - - Реализация для `Any` должна быть описана раньше, чем структуры. - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Protocol.html#derive/3) diff --git a/modules/45-structs/50-any-protocols/en/data.yml b/modules/45-structs/50-any-protocols/en/data.yml index 1e22bd8..d95bb44 100644 --- a/modules/45-structs/50-any-protocols/en/data.yml +++ b/modules/45-structs/50-any-protocols/en/data.yml @@ -1,2 +1,3 @@ +--- name: Any protocols tips: [] diff --git a/modules/45-structs/50-any-protocols/ru/data.yml b/modules/45-structs/50-any-protocols/ru/data.yml index 31a93c3..a5f2c25 100644 --- a/modules/45-structs/50-any-protocols/ru/data.yml +++ b/modules/45-structs/50-any-protocols/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Общие протоколы tips: - | diff --git a/modules/50-errors/10-errors-handling/description.en.yml b/modules/50-errors/10-errors-handling/description.en.yml deleted file mode 100644 index 236000a..0000000 --- a/modules/50-errors/10-errors-handling/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Errors handling, exceptions -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/50-errors/10-errors-handling/description.ru.yml b/modules/50-errors/10-errors-handling/description.ru.yml deleted file mode 100644 index 270c7e0..0000000 --- a/modules/50-errors/10-errors-handling/description.ru.yml +++ /dev/null @@ -1,137 +0,0 @@ ---- -name: Обработка ошибок, исключения -theory: | - - В Elixir есть механизм исключений, однако используется он иначе, чем в классических языках программирования. Для начала ознакомимся с исключениями. - - Исключения выбрасываются через `raise`: - - ```elixir - raise "Boom!" - # => ** (RuntimeError) Boom! - # => iex:149: (file) - ``` - - Исключения создаются через `defexception`: - - ```elixir - defmodule MyError do - defexception message: "boom!" - end - - raise MyError - # => ** (MyError) boom! - # => iex:150: (file) - - raise MyError, message: "different boom!" - # => ** (MyError) different boom! - # => iex:150: (file) - ``` - - Исключения перехватываются через `try` и `rescue`: - - ```elixir - try do - raise "boom!" - rescue - e in RuntimeError -> e - end - # => %RuntimeError{message: "boom!"} - - try do - raise "boom!" - rescue - RuntimeError -> "oops" - end - # => "oops" - ``` - - Как уже было сказано, в мире Elixir используется философия "пусть сломается" (let it crash), из-за чего исключения при написании Elixir кода зачастую не обрабатываются. Почему? Из-за того, что Elixir код всегда исполняется в отдельных процессах (акторах), которые работают независимо. Поэтому падение одного из сотни или тысячи процессов никак не повлияет на работу всей системы. Про процессы (акторы) подробнее поговорим в следующем модуле, а пока продолжим изучать исключения. - - Так как Elixir программисты зачастую игнорируют прямую обработку исключений, иногда бывает полезно поймать исключение, записать в логи информацию об ошибке и пробросить исключение дальше по стеку. Повторный выброс исключения происходит через `reraise`: - - ```elixir - require Logger - - try do - 1 / 0 - rescue - e -> - Logger.warning(Exception.format(:error, e, __STACKTRACE__)) - reraise e, __STACKTRACE__ - end - - # => ** (ArithmeticError) bad argument in arithmetic expression: 1 / 0 - # => :erlang./(1, 0) - # => iex:157: (file) - # => iex:161: (file) - - # => 17:48:09.214 [warning] ** (ArithmeticError) bad argument in arithmetic expression - # => :erlang./(1, 0) - # => iex:157: (file) - # => (elixir 1.15.0) src/elixir.erl:374: anonymous fn/4 in :elixir.eval_external_handler/1 - # => (stdlib 4.3.1.1) erl_eval.erl:748: :erl_eval.do_apply/7 - # => (stdlib 4.3.1.1) erl_eval.erl:987: :erl_eval.try_clauses/10 - # => (elixir 1.15.0) src/elixir.erl:359: :elixir.eval_forms/4 - # => (elixir 1.15.0) lib/module/parallel_checker.ex:112: Module.ParallelChecker.verify/1 - # => (iex 1.15.0) lib/iex/evaluator.ex:331: IEx.Evaluator.eval_and_inspect/3 - ``` - - По сути, исключения в Elixir используются по прямому назначению, они выбрасываются только когда произошло действительно что-то, чего в нормальной ситуации произойти не должно. В большинстве же остальных языков программирования исключения используются как еще один способ управлять потоком выполнения программы. Почти оператор `GOTO`, только замаскированный. - - Иногда нужно подчистить какой-то ресурс, при возникновении исключения, тогда подойдет `after`: - - ```elixir - {:ok, file} = File.open("sample", [:utf8, :write]) - - try do - IO.write(file, "hello") - raise "oops" - after - File.close(file) - end - ``` - - Если же исключения не возникло, но нужно выполнить еще какой-то код, тогда подойдет `else`: - - ```elixir - x = 2 - - try do - 1 / x - rescue - ArithmeticError -> - :infinity - else - y when y < 1 and y > -1 -> :small - _ -> :large - end - # => :small - ``` - -instructions: | - - Создайте функцию `my_div`, которая выбрасывает исключение `ArgumentError` с сообщением `Divide x by zero is prohibited!`, где `x` - первый переданный аргумент. Для деления с округлением воспользуйтесь `Integer.floor_div`: - - ```elixir - Solution.my_div(128, 2) - # => 64 - - Solution.my_div(128, 0) - # => ** (ArgumentError) Divide 128 by zero is prohibited! - # => iex:142: Solution.my_div/2 - # => iex:149: (file) - - Solution.my_div(10, 0) - # => ** (ArgumentError) Divide 10 by zero is prohibited! - # => iex:142: Solution.my_div/2 - # => iex:149: (file) - ``` - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Exception.html) - - | - [Статья про исключения](https://belaycpp.com/2021/06/16/exceptions-are-just-fancy-gotos/) - - | - [Исключения на примере JS](https://ru.hexlet.io/courses/js_errors/lessons/exceptions/theory_unit) diff --git a/modules/50-errors/10-errors-handling/en/data.yml b/modules/50-errors/10-errors-handling/en/data.yml index 3736fc7..13ff0e8 100644 --- a/modules/50-errors/10-errors-handling/en/data.yml +++ b/modules/50-errors/10-errors-handling/en/data.yml @@ -1,2 +1,3 @@ +--- name: Errors handling, exceptions tips: [] diff --git a/modules/50-errors/10-errors-handling/ru/data.yml b/modules/50-errors/10-errors-handling/ru/data.yml index 174e6fe..33f87b0 100644 --- a/modules/50-errors/10-errors-handling/ru/data.yml +++ b/modules/50-errors/10-errors-handling/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Обработка ошибок, исключения tips: - | diff --git a/modules/50-errors/20-tuple-errors-processing/description.en.yml b/modules/50-errors/20-tuple-errors-processing/description.en.yml deleted file mode 100644 index 2de1801..0000000 --- a/modules/50-errors/20-tuple-errors-processing/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Errors handling using tuples -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/50-errors/20-tuple-errors-processing/description.ru.yml b/modules/50-errors/20-tuple-errors-processing/description.ru.yml deleted file mode 100644 index 6cf924d..0000000 --- a/modules/50-errors/20-tuple-errors-processing/description.ru.yml +++ /dev/null @@ -1,72 +0,0 @@ ---- - -name: Обработка ошибок с помощью кортежей -theory: | - - Как было описано в прошлом упражнении, в Elixir не используют исключения напрямую для обработки ошибок и управлением работы программы. Вместо этого из функций возвращают кортежи, если операция была успешна, то `{:ok, result}`, где `result` - результат выполнения функции. В случае ошибки возвращается кортеж вида `{:error, reason}` - где `reason` причина ошибки, может быть любого формата. Рассмотрим примеры: - - ```elixir - File.copy("/not_existing_dir", "/existing_dir") - # => {:error, :enoent} - File.copy("/some_dir", "/existing_dir") - # => {:ok, 210} - ``` - - Важно отметить, что для булевых функций, лучше возвращать не кортеж, а `true` или `false`. - - При таком подходе к обработке ошибок, органично использовать паттерн-матчинг: - - ```elixir - defmodule Example do - @magic_number 10 - - def multiply_by_two(number) when is_integer(number) do - {:ok, number * 2} - end - - def multiply_by_two(number) do - {:error, :not_number} - end - - def magic(number) do - case multiply_by_two(number) do - {:ok, result} -> {:ok, result + @magic_number} - {:error, reason} -> {:error, :no_magic_here} - end - end - end - - Example.multiply_by_two(2) - # => {:ok, 4} - Example.multiply_by_two("string") - # => {:error, :not_number} - - Example.magic(2) - # => {:ok, 4} - Example.magic("string") - # => {:error, :no_magic_here} - ``` - - Для простых функций не обязательно возвращать кортеж `{:ok, result}`, достаточно вернуть только `result`. Однако если функция в разных условиях возвращает разный результат, например, словарь с разным набором ключей, тогда лучше использовать кортежи и точнее паттерн-матчить их. - -instructions: | - - Реализуйте функцию `compare`, которая сравнивает два переданных *числа*: - - ```elixir - Solution.compare(2, 3) - # => {:ok, :less} - Solution.compare(3, 3) - # => {:ok, :equal} - Solution.compare(4, 3) - # => {:ok, :greater} - - Solution.compare("", 3) - # => {:error, :not_number} - Solution.compare(2, []) - # => {:error, :not_number} - ``` - -tips: - - | - [Пример модуля с описанным подходом к обработке ошибок](https://hexdocs.pm/elixir/File.html) diff --git a/modules/50-errors/20-tuple-errors-processing/en/data.yml b/modules/50-errors/20-tuple-errors-processing/en/data.yml index 95b0b87..90021bb 100644 --- a/modules/50-errors/20-tuple-errors-processing/en/data.yml +++ b/modules/50-errors/20-tuple-errors-processing/en/data.yml @@ -1,2 +1,3 @@ +--- name: Errors handling using tuples tips: [] diff --git a/modules/50-errors/20-tuple-errors-processing/ru/data.yml b/modules/50-errors/20-tuple-errors-processing/ru/data.yml index 1679a05..5c3f0b0 100644 --- a/modules/50-errors/20-tuple-errors-processing/ru/data.yml +++ b/modules/50-errors/20-tuple-errors-processing/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Обработка ошибок с помощью кортежей tips: - > diff --git a/modules/50-errors/30-with-operator/description.en.yml b/modules/50-errors/30-with-operator/description.en.yml deleted file mode 100644 index 38418c2..0000000 --- a/modules/50-errors/30-with-operator/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: With operator -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/50-errors/30-with-operator/description.ru.yml b/modules/50-errors/30-with-operator/description.ru.yml deleted file mode 100644 index df97368..0000000 --- a/modules/50-errors/30-with-operator/description.ru.yml +++ /dev/null @@ -1,147 +0,0 @@ ---- - -name: Оператор with -theory: | - - Рассмотрим оператор `with`, зачем нужен и как используется. Для начала, опишем пример: - - ```elixir - defmodule Example do - require Integer - - def inc_even(num) do - if Integer.is_even(num) do - num + 1 - else - {:error, :not_even} - end - end - - def stringify_odd(num) do - if Integer.is_odd(num) do - Integer.to_string(num) - else - {:error, :not_odd} - end - end - end - ``` - - Проблема в том, что при попытке скомпоновать эти функции через оператор пайплайна `|>` будут возникать ошибки, если аргумент окажется неподходящим: - - ```elixir - 2 |> Example.inc_even() |> Example.stringify_odd() - # => "3" - - 2 |> Example.stringify_odd() |> Example.inc_even() - # => {:error, :not_even} - ``` - - Можно попытаться решить проблему через `case`: - - ```elixir - case Example.inc_even(3) do - {:error, reason} -> reason - - result -> - case Example.stringify_odd(result) do - {:error, reason} -> reason - - stringified -> stringified - end - end - - # => :not_even - ``` - - Однако, такой подход начинает хуже работать с увеличением вложенности операций. Для *выпрямления* таких вычислений используется конструкция `with`, с помощью которой описывается удачный путь вычислений (happy path) и комбинировать вызовы функций с разным форматом данных. Перепишем на `with`: - - ```elixir - with incremented <- Example.inc_even(2), - stringified <- Example.stringify_odd(incremented), - do: stringified - - # => "3" - # по сути получился аналог - # 2 |> Example.inc_even() |> Example.stringify_odd() - ``` - - Оператор `with` полезен тем, что можно обрабатывать неудачные вызовы функций в ветке `else`: - - ```elixir - with incremented <- Example.inc_even(3), - stringified <- Example.stringify_odd(incremented) do - stringified - else - {:error, reason} -> reason - end - - # => :not_odd - ``` - - Внутри `with` можно использовать разные функции с разными возвращаемыми значениями, например: - - ```elixir - user = %{name: "John"} - with updated_user <- Map.put(user, :age, 20), - true <- updated_user[:age] == 20, - %{hobby: hobby} <- Map.put(updated_user, :hobby, "diving"), - do: hobby - - # => "diving" - ``` - - Для функции предиката добавим еще одну ветку и поменяем значение по ключу `age`: - - ```elixir - user = %{name: "John"} - with updated_user <- Map.put(user, :age, 22), - true <- updated_user[:age] == 20, - %{hobby: hobby} <- Map.put(updated_user, :hobby, "diving") do - hobby - else - false -> "incorrect age" - end - - # => "incorrect age" - ``` - - С помощью `with` проще структурировать ошибки, которые могут возникнуть в цепочке вычислений, однако важно не увлечься при описании такой цепочки, потому что с ростом операций становится тяжелее понять что происходит с данными. В таких случаях лучше сгруппировать часть операции в отдельные функции и в итоговом `with` описать меньшее количество вызываемых функций. Хорошим примером является фреймворк Phoenix, в котором при генерации ресурса, например пользователя, создается такой код для контроллера: - - ```elixir - def create(conn, params) do - with {:ok, user} <- Users.create_user(params) do - conn - |> put_status(:created) - |> render("show.json", user: user) - end - ``` - - На верхнем уровне Phoenix перехватывает ошибки создания ресурса, так как оно типично: `{:error, changeset}`. Поэтому нет необходимости описывать отдельно ветку `else`. - -instructions: | - - Реализуйте функцию `validate`, которая проверяет переданный аргумент на следующие условия: - - аргумент является строкой - - длина строки меньше или равна 8 - - длина строки больше или равна 2 - - Примеры работы функции: - - ```elixir - Solution.validate("some") - # => {:ok, "some"} - Solution.validate("hello!!") - # => {:ok, "hello!!"} - - Solution.validate(1) - # => {:error, :not_binary} - Solution.validate("a") - # => {:error, :too_short} - Solution.validate("hello, world!") - # => {:error, :too_long} - ``` - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Kernel.SpecialForms.html#with/1) diff --git a/modules/50-errors/30-with-operator/en/data.yml b/modules/50-errors/30-with-operator/en/data.yml index 3d4437e..652a3cf 100644 --- a/modules/50-errors/30-with-operator/en/data.yml +++ b/modules/50-errors/30-with-operator/en/data.yml @@ -1,2 +1,3 @@ +--- name: With operator tips: [] diff --git a/modules/50-errors/30-with-operator/ru/data.yml b/modules/50-errors/30-with-operator/ru/data.yml index c1ede63..03de120 100644 --- a/modules/50-errors/30-with-operator/ru/data.yml +++ b/modules/50-errors/30-with-operator/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Оператор with tips: - > diff --git a/modules/55-processes/10-processes-intro/description.en.yml b/modules/55-processes/10-processes-intro/description.en.yml deleted file mode 100644 index fceb11b..0000000 --- a/modules/55-processes/10-processes-intro/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Intoduction to processes -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/55-processes/10-processes-intro/description.ru.yml b/modules/55-processes/10-processes-intro/description.ru.yml deleted file mode 100644 index 9d038fd..0000000 --- a/modules/55-processes/10-processes-intro/description.ru.yml +++ /dev/null @@ -1,69 +0,0 @@ ---- -name: Знакомство с процессами -theory: | - - Весь Elixir код запускается в рамках *процесса*. Важно понимать, что процесс в Elixir не является аналогией процесса операционной системы. - - Процессы в Elixir являются зелеными потоками (green threads) - это более легковесные процессы, чем в операционной системе, которые выполняются в рамках виртуальной машины языка программирования. В случае Elixir это BEAM. Внутри виртуальной машины выделяются отдельные планировщики, как и в операционной системе, которые следят за тем, чтобы каждый процесс работал определенный квант времени, например 4 миллисекунды. Благодаря такой отлаженной работы планировщиков нагрузка на процессор распределяется более плавно относительно каждого из ядер, то есть ситуации, когда одно ядро нагружено сильнее другого возникают намного реже. По сути, BEAM реализует на практике вытесняющую многозадачность. - - Процессы изолированы и выполняются *конкурентно* относительно друг друга. Общаются процессы между собой через *сообщения*, забавный факт, что первая предложенная Аланом Кеем модель ООП как раз описывалась как множество объектов с внутренним состоянием, которые коммуницируют между собой через сообщения. - - Из-за легковесности процессов, зачастую в Elixir приложениях запущенны сотни, а то и тысячи процессов. Для создания процесса используем функцию `spawn`: - - ```elixir - spawn(fn -> 2 * 2 end) - # => #PID<0.43.0> - - # создадим 100 тысяч процессов - processes = 0..100_000 |> Enum.map(fn _ -> spawn(fn -> 2 + 2 end) end) - # => много иднтификаторов процессов - - hd(processes) - # => #PID<0.5249.9> - List.last(processes) - # => #PID<0.6945.12> - ``` - - Функция `spawn` принимает аргументом функцию, которую запускает в отдельном процессе. Заметьте, что вызов `spawn` возвращает не результат выполнения переданной функции, а идентификатор процесса (process identifier) или ПИД (PID). Процесс, который был создан в предыдущем примере, после выполнения функции завершился. - - ```elixir - pid = spawn(fn -> 2 * 2 end) - # => #PID<0.44.0> - - Process.alive?(pid) - # => false - ``` - - С помощью функции `self` мы можем узнать идентификатор нынешнего процесса, в котором была вызвана функция: - - ```elixir - self() - # => #PID<0.41.0> - - Process.alive?(self()) - # => true - ``` - -instructions: | - - Создайте функцию `run_in_process`, которая принимает функцию и создает процесс, который выполняет эту функцию: - - ```elixir - Solution.run_in_process(fn -> String.upcase("code basics") end) - # => #PID<0.42.0> - - Solution.run_in_process(fn -> Process.sleep(1000) end) - # => #PID<0.43.0> - ``` - -tips: - - | - [Про green threads](https://ru.wikipedia.org/wiki/Green_threads) - - | - [Про ООП в Erlang](https://www.infoq.com/interviews/johnson-armstrong-oop/) - - | - [Видео про BEAM и процессы](https://www.youtube.com/watch?v=JvBT4XBdoUE) - - | - [Официальная документация](https://hexdocs.pm/elixir/Process.html) - - | - [Про вытесняющую многозадачность](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D1%82%D0%B5%D1%81%D0%BD%D1%8F%D1%8E%D1%89%D0%B0%D1%8F_%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%BD%D0%BE%D1%81%D1%82%D1%8C) diff --git a/modules/55-processes/10-processes-intro/en/data.yml b/modules/55-processes/10-processes-intro/en/data.yml index 03ed723..01e2e2e 100644 --- a/modules/55-processes/10-processes-intro/en/data.yml +++ b/modules/55-processes/10-processes-intro/en/data.yml @@ -1,2 +1,3 @@ +--- name: Intoduction to processes tips: [] diff --git a/modules/55-processes/10-processes-intro/ru/data.yml b/modules/55-processes/10-processes-intro/ru/data.yml index fb9c680..a19d542 100644 --- a/modules/55-processes/10-processes-intro/ru/data.yml +++ b/modules/55-processes/10-processes-intro/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Знакомство с процессами tips: - | diff --git a/modules/55-processes/20-processes-mailbox/description.en.yml b/modules/55-processes/20-processes-mailbox/description.en.yml deleted file mode 100644 index f8188ee..0000000 --- a/modules/55-processes/20-processes-mailbox/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Processes mailbox -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/55-processes/20-processes-mailbox/description.ru.yml b/modules/55-processes/20-processes-mailbox/description.ru.yml deleted file mode 100644 index 1e7cc84..0000000 --- a/modules/55-processes/20-processes-mailbox/description.ru.yml +++ /dev/null @@ -1,130 +0,0 @@ ---- -name: Почтовый ящик процессов -theory: | - - Как было упомянуто в прошлом занятии, процессы общаются между собой с помощью *сообщений*. Сообщения всегда отправляются *асинхронно*, без подтверждения доставки сообщения процессу. Чтобы получить результат обработки сообщения другим процессом, используется блокировка в ожидании ответного сообщения от другого процесса, но это уже тонкости реализации синхронного вызова. По сути способ синхронизации результата это низкоуровневые детали, с которыми сталкиваться скорее всего не придется. Для отправки сообщений используется функция `send`. Каждый процесс имеет собственный *почтовый ящик*, который он читает с помощью функции `receive`. Рассмотрим на примере: - - ```elixir - send(self(), {:hello, "world"}) - # => {:hello, "world"} - - receive do - {:hello, msg} -> msg - {:world, _} -> "unmatched expression" - end - # => "world" - ``` - - Блок кода `receive` при получении сообщения, проходится по всему почтовому ящику в поиске совпадений по шаблону сообщений. - - Отправка сообщений через `send` является неблокирующей операцией, то есть сообщения процессу отправляются *асинхронно*. Так как весь Elixir код выполняется в каком-то процессе, то процесс может отправлять сообщения самому себе. - - Почтовые ящики у процессов могут переполняться, поэтому важно указывать базовый паттерн, в который попадут все остальные сообщения из ящика. Блок `receive` закончит выполнение при первом совпадении паттерна, в ином случае процесс заблокируется в ожидании подходящего сообщения, либо, по истечению указанного таймаута: - - ```elixir - receive do - {:hello, msg} -> msg - after - 1_000 -> "message await stopped after 1 second" - end - # => "message await stopped after 1 second" - ``` - - Теперь создадим отдельный процесс, который отправит сообщение в процесс родитель: - - ```elixir - parent = self() - # => #PID<0.105.0> - - spawn(fn -> send(parent, {:hello, self()}) end) - # => #PID<0.6946.12> - - receive do - {:hello, pid} -> "Got hello from #{inspect(pid)}" - end - # => "Got hello from #PID<0.6946.12>" - ``` - - Так как `receive` завершается по таймауту или успешной обработке сообщения, то как сделать обработку процессом сообщений постоянной? Рекурсивный вызов `receive`, конечно же! - - ```elixir - defmodule Processor do - def process() do - receive do - {:hello, msg} -> - IO.puts(msg) - process() - - {:world, msg} -> - IO.puts(String.upcase(msg)) - process() - - {:exit, _} -> IO.puts("Shutdown processor...") - end - end - end - - processor = spawn(fn -> Processor.process() end) - # => #PID<0.6952.12> - Process.alive?(processor) - # => true - - send(processor, {:hello, "code basic"}) - # для просмотра почтового ящика родительского процесса - # далее по коду будет подразумеваться, что эта строчка кода - # будет вызываться после каждой отправки сообщения другому процессу - Process.info(parent, :messages) - # => code basic - - Process.alive?(processor) - # => true - - send(processor, {:world, "code basic"}) - # => CODE BASIC - Process.alive?(processor) - # => true - - send(processor, {:exit, ""}) - # => Shutdown processor... - Process.alive?(processor) - # => false - ``` - -instructions: | - - Создайте функцию `calculate` которая принимает процесс-получатель и поддерживает операции `:+`, `:-`, `:*` в виде сообщений от процесса и при обработке возвращает сообщение процессу отправителю с результатом, функция должна поддерживать постоянную обработку сообщений. При передаче сообщения `:exit`, функция перестает обрабатывать входящие сообщения: - - ```elixir - parent = self() - calculator = spawn(fn -> Solution.calculate(parent) end) - - send(calculator, {:+, [2, 5]}) - receive do - {:ok, result} -> result - end - # => 7 - Process.alive?(calculator) - # => true - - send(calculator, {:*, [2, 5]}) - receive do - {:ok, result} -> result - end - # => 10 - Process.alive?(calculator) - # => true - - send(calculator, {:exit}) - receive do - {:ok, result} -> result - end - # => :exited - Process.alive?(calculator) - # => false - ``` - -tips: - - | - [Конкурентность на примере процессов Elixir](https://www.youtube.com/watch?v=A4x6IfceJCM) - - | - [Официальная документация](https://hexdocs.pm/elixir/Process.html) diff --git a/modules/55-processes/20-processes-mailbox/en/data.yml b/modules/55-processes/20-processes-mailbox/en/data.yml index 970a14e..e4fa495 100644 --- a/modules/55-processes/20-processes-mailbox/en/data.yml +++ b/modules/55-processes/20-processes-mailbox/en/data.yml @@ -1,2 +1,3 @@ +--- name: Processes mailbox tips: [] diff --git a/modules/55-processes/20-processes-mailbox/ru/data.yml b/modules/55-processes/20-processes-mailbox/ru/data.yml index a44418c..fd18170 100644 --- a/modules/55-processes/20-processes-mailbox/ru/data.yml +++ b/modules/55-processes/20-processes-mailbox/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Почтовый ящик процессов tips: - > diff --git a/modules/55-processes/30-processes-state/description.en.yml b/modules/55-processes/30-processes-state/description.en.yml deleted file mode 100644 index f35b2d2..0000000 --- a/modules/55-processes/30-processes-state/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Processes state -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/55-processes/30-processes-state/description.ru.yml b/modules/55-processes/30-processes-state/description.ru.yml deleted file mode 100644 index 9b79456..0000000 --- a/modules/55-processes/30-processes-state/description.ru.yml +++ /dev/null @@ -1,141 +0,0 @@ ---- -name: Состояние процесса -theory: | - - В прошлом упражнении мы создали процесс-калькулятор, который только обрабатывает входящие запросы, не храня никакого *состояния*. Но как его сохранить? Основная идея процесса, который обрабатывает более одного сообщения за раз, это вызов рекурсивной функции, которая продолжит основной цикл обработки сообщений. Рассмотрим пример с процессом-счетчиком: - - ```elixir - defmodule Counter do - def init(parent, initial_state \\ 0) do - process(parent, initial_state) - end - - defp process(parent, state) do - receive do - :inc -> - new_state = state + 1 - send(parent, {:ok, new_state}) - process(parent, new_state) - - :dec -> - new_state = state - 1 - send(parent, {:ok, new_state}) - process(parent, new_state) - - :current -> - send(parent, {:ok, state}) - process(parent, state) - - :reset -> - send(parent, {:ok, 0}) - process(parent, 0) - end - end - end - ``` - - В процессе-счетчике мы вынесли функцию запуска процесса, запомнили процесс-родитель и инициализировали состояние процесса-счетчика нулем. Затем при обработке сообщения изменяется состояние процесса, которое передается дальше в рекурсивный вызов функции `process`. Теперь запустим счетчик и проверим его работу: - - Важно, что идентификатор родительского процесса мы передаем снаружи, так как вызов `self()` внутри модуля вернет иной идентификатор. - - ```elixir - parent = self() - counter = spawn(fn -> Counter.init(parent) end) - - send(counter, :current) - # для просмотра почтового ящика родительского процесса - # далее по коду будет подразумеваться, что эта строчка кода - # будет вызываться после каждой отправки сообщения другому процессу - Process.info(parent, :messages) - # => {:messages, [ok: 0]} - - send(counter, :inc) - # => {:ok, 1} - send(counter, :inc) - # => {:ok, 2} - - send(counter, :dec) - # => {:ok, 1} - - send(counter, :inc) - # => {:ok, 2} - - send(counter, :reset) - # => {:ok, 0} - - send(counter, :dec) - # => {:ok, -1} - ``` - - Важно заметить, что каждый процесс хранит свое состояние *отдельно* от других процессов: - - ```elixir - parent = self() - first_counter = spawn(fn -> Counter.init(parent) end) - second_counter = spawn(fn -> Counter.init(parent) end) - - send(first_counter, :inc) - send(first_counter, :inc) - send(first_counter, :inc) - - send(second_counter, :dec) - send(second_counter, :dec) - - send(first_counter, :current) - # => {:ok, 3} - - send(second_counter, :current) - # => {:ok, -2} - ``` - - Состояние не обязательно выражается числом, в него можно складывать что-угодно, начиная от чисел и заканчивая словарем со ссылками на другие процессы, к примеру. - -instructions: | - - В этот раз создайте процесс кеш-сервер, который хранит в состоянии словарь. Напишите функцию `init`, которая принимает родительский процесс и начальное состояние (как в примерах выше). Затем добавьте обработку следующих сообщений: - - `:put` положить по переданному ключу `key` значение `value` в состояние кеш-сервера, возвращает кортеж `{:ok, value}`; - - `:get` достать из состояния процесса значение по переданному ключу, при отсутствии значения вернуть кортеж `{:error, :not_found}`; - - `:drop` убрать из состояния процесса переданный ключ; - - `:exit` перестать обрабатывать входящие сообщения кеш-сервером, возвращает кортеж `{:ok, :exited}`; - - а еще добавьте обработку невалидных сообщений, чтобы процесс не ломался, если ему передать что-то не то (вернуть кортеж `{:error, :unrecognized_operation}`). - - ```elixir - parent = self() - cache_server = spawn(fn -> CacheServer.init(parent) end) - - send(cache_server, {:put, {:hello, "world"}}) - # => {:ok, "world"} - - send(cache_server, {:get, {:hello}}) - # => {:ok, "world"} - - send(cache_server, {:get, {:some}}) - # => {:error, :not_found}) - - send(cache_server, {:drop, {:hello}}) - # => {:ok, :hello} - - send(cache_server, {:get, {:hello}}) - # => {:error, :not_found}) - - send(cache_server, {:something, {1, 2, 3}}) - # => {:error, :unrecognized_operation} - Process.alive?(cache_server) - # => true - - send(cache_server, :boom) - # => {:error, :unrecognized_operation} - Process.alive?(cache_server) - # => true - - send(cache_server, {:exit}) - # => {:ok, :exited} - Process.alive?(cache_server) - # => false - ``` - -tips: - - | - [Конкурентность на примере процессов Elixir](https://www.youtube.com/watch?v=A4x6IfceJCM) - - | - [Официальная документация](https://hexdocs.pm/elixir/Process.html) diff --git a/modules/55-processes/30-processes-state/en/data.yml b/modules/55-processes/30-processes-state/en/data.yml index da570e9..7f9566d 100644 --- a/modules/55-processes/30-processes-state/en/data.yml +++ b/modules/55-processes/30-processes-state/en/data.yml @@ -1,2 +1,3 @@ +--- name: Processes state tips: [] diff --git a/modules/55-processes/30-processes-state/ru/data.yml b/modules/55-processes/30-processes-state/ru/data.yml index ca2f05f..ceac150 100644 --- a/modules/55-processes/30-processes-state/ru/data.yml +++ b/modules/55-processes/30-processes-state/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Состояние процесса tips: - > diff --git a/modules/55-processes/35-links/description.en.yml b/modules/55-processes/35-links/description.en.yml deleted file mode 100644 index 6253022..0000000 --- a/modules/55-processes/35-links/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Process links -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/55-processes/35-links/description.ru.yml b/modules/55-processes/35-links/description.ru.yml deleted file mode 100644 index 403422a..0000000 --- a/modules/55-processes/35-links/description.ru.yml +++ /dev/null @@ -1,158 +0,0 @@ ---- -name: Связь процессов -theory: | - - Так как процессы изолированы друг от друга, то возникновение ошибки в одном процессе никак не отражается на работе остальных: - - ```elixir - spawn(fn -> raise "boom" end) - # => 17:27:46.980 [error] Process #PID<0.277.0> raised an exception - # => ** (RuntimeError) boom - # => iex:156: (file) - ``` - - Однако, в некоторых ситуациях нужно, чтобы процессы были связаны между собой для обработки ошибок. Создание связи происходит через функцию `spawn_link`: - - ```elixir - self() - # => #PID<0.105.0> - - spawn_link(fn -> raise "boom" end) - # => ** (EXIT from #PID<0.105.0>) shell process exited with reason: an exception was raised: - # => ** (RuntimeError) boom - # => iex:158: (file) - - # => 17:30:45.109 [error] Process #PID<0.280.0> raised an exception - # => ** (RuntimeError) boom - # => iex:158: (file) - ``` - - Теперь, когда процессы связаны, возникновение ошибки в созданном процессе так же вызвало ошибку и в процессе, с которым он был связан. По сути, связанный процесс получил сигнал `EXIT` и аварийно завершился. - - Благодаря связям, можно создавать процессы *супервизоры* (supervisors), которые следят за порожденными процессами *рабочими* (workers). При возникновении внештатных ситуаций процесс супервизор перезапускает наблюдаемый им процесс. Такая архитектура лежит в основе Elixir и Erlang приложений и называется *дерево супервизии*, внутри которого отдельные процессы супервизоры запускают другие процессы и следят за их работой, перезапуская при необходимости. Корнем в этом дереве выступает само приложение, внутри которого запущены остальные процессы. Выглядит дерево супервизии примерно так: - - ```elixir - # супервизор игровой сессии -- обработчики игровых сессий - # / - # процесс приложения -- супервизор обработки платежей -- обработчики платежей - # \ - # супервизор рассылки уведомлений -- отправители уведомлений - ``` - - Теперь рассмотрим причины завершения процессов. Когда процесс заканчивает свою работу, он *завершается* (finishes) в *нормальном* (normal) режиме, по сути нормальное завершение процесса выглядит как прямой вызов функции `exit(:normal)` из модуля `Process`: - - ```elixir - spawn_link(fn -> exit(:normal) end) - # => #PID<0.282.0> - spawn(fn -> exit(:normal) end) - # => #PID<0.283.0> - ``` - - Результат работы функций идентичный из-за завершения процесса в режиме `:normal`. Если же причина будет другой, то завершение процесса будет расцениваться как *аварийное*: - - ```elixir - spawn(fn -> exit(:boom_reason) end) - # => #PID<0.284.0> - - spawn_link(fn -> exit(:boom_reason) end) - # => ** (EXIT from #PID<0.281.0>) shell process exited with reason: :boom_reason - # - # => Interactive Elixir (1.15.0) - press Ctrl+C to exit (type h() ENTER for help) - ``` - - Так как процесс интерактивной оболочки был связан напрямую с новым процессом, который аварийно завершился, то процесс интерактивной оболочки тоже аварийно завершился. А дальше *супервизор интерактивной оболочки* перехватил аварийное завершение *процесса-оболочки* и перезапустил его. - - Именно так и работает дерево супервизии. Но для перезапуска нужно как-то понять, каким образом завершился наблюдаемый процесс. Для этих целей используется перехват выхода или перехват завершения процесса (trap exits) через специальный флаг, который выставляется для настройки процесса. Процессы можно конфигурировать, например размер кучи, приоритет, перехват завершения и многое другое. Нас интересует флаг перехвата, который конвертирует все сигналы завершения процесса в сообщения вида `{'EXIT', from, reason}`. Настройка процессов таким образом не является стандартной практикой, так как фреймворк OTP предоставляет специальную абстракцию под это, которая и называется `Supervisor`. С OTP фреймворком познакомимся чуть позже, когда разберемся как процессы работают на более низком уровне. - - Теперь настроим процесс на перехват сигналов о завершении: - - ```elixir - Process.flag(:trap_exit, true) - # => false - - spawn_link(fn -> 1 + 1 end) - # => #PID<0.287.0> - Process.info(self(), :messages) - # => {:messages, [{:EXIT, #PID<0.287.0>, :normal}]} - ``` - - Как видно из кода, процесс посчитал выражение и завершился в штатном режиме. Теперь завершим процесс с другим сигналом: - - ```elixir - spawn_link(fn -> exit(:not_okay_reason) end) - # => #PID<0.288.0> - Process.info(self(), :messages) - # =>{:messages, [{:EXIT, #PID<0.288.0>, :not_okay_reason}]} - ``` - - Теперь мы можем перехватывать любые сообщения о завершении и реагировать на них: - - ```elixir - receive do - {:EXIT, pid, :normal} -> "Process #{inspect(pid)} exited normally" - {:EXIT, pid, reason} -> "Process #{inspect(pid)} exited abnormally #{reason}" - end - ``` - - Более того, теперь мы можем перехватывать и исключения: - - ```elixir - spawn_link(fn -> raise "boom!" end) - # => #PID<0.107.0> - # - # => 02:15:35.982 [error] Process #PID<0.107.0> raised an exception - # => ** (RuntimeError) boom! - # => iex:4: (file) - - Process.info(self(), :messages) - # => {:messages, [{:EXIT, #PID<0.107.0>, {%RuntimeError{message: "boom!"}, [{:elixir_eval, :__FILE__, 1, [file: ~c"iex", line: 4]}]}}]} - ``` - -instructions: | - - В файле с решением описан модуль `Worker`. Для работы с ним, нужно создать и связать процесс с этим модулем следующим образом: - - ```elixir - number = 5 - spawn_link(fn -> Worker.work(number) end) - ``` - - После этого, `Worker` проверяет число по правилам классической задачи с собеседований `FooBar` и процесс завершается с соответствующим сигналом: - - число кратно 3 и 5 - `:foobar`; - - число кратно 3 - `:foo`; - - число кратно 3 - `:bar`; - - в ином случае процесс завершается в штатном режиме `:normal`. - - Создайте функцию `supervise_foobar` которая принимает число, вызывает `Worker` и на основе сигнала о завершении формирует строку, где вместо переданного числа подставляется `Foo`, `Bar`, `FooBar` либо ничего, затем число увеличивается на *единицу* и процесс проверки числа и сбора строки идет дальше. - - Если переданное число больше 100 или меньше 1, то продолжать сбор строки не нужно. Не забудьте о `Process.flag(:trap_exit, true)`, так как иначе не получится собрать информацию о сигналах завершения `Worker`. Примеры: - - ```elixir - Solution.supervise_foobar(0) - # => "" - - Solution.supervise_foobar(-10) - # => "" - - Solution.supervise_foobar(11123) - # => "" - - Solution.supervise_foobar(80) - # => "Bar Foo Foo Bar Foo FooBar Foo Bar Foo Foo Bar" - - Solution.supervise_foobar(100) - # => "Bar" - - Solution.supervise_foobar(75) - # => "FooBar Foo Bar Foo Foo Bar Foo FooBar Foo Bar Foo Foo Bar" - ``` - -tips: - - | - [Отказоустойчивость в Elixir](https://www.youtube.com/watch?v=mkGq1WoEvI4) - - | - [Официальная документация](https://hexdocs.pm/elixir/Process.html#exit/2) - - | - [Документация по настройке процессов](https://www.erlang.org/doc/man/erlang.html#process_flag-2) - - | - [Документация по супервизорам](https://hexdocs.pm/elixir/Supervisor.html) diff --git a/modules/55-processes/35-links/en/data.yml b/modules/55-processes/35-links/en/data.yml index f558b15..a6cf0cf 100644 --- a/modules/55-processes/35-links/en/data.yml +++ b/modules/55-processes/35-links/en/data.yml @@ -1,2 +1,3 @@ +--- name: Process links tips: [] diff --git a/modules/55-processes/35-links/ru/data.yml b/modules/55-processes/35-links/ru/data.yml index f1f2531..a288933 100644 --- a/modules/55-processes/35-links/ru/data.yml +++ b/modules/55-processes/35-links/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Связь процессов tips: - | diff --git a/modules/55-processes/40-tasks-and-agents/description.en.yml b/modules/55-processes/40-tasks-and-agents/description.en.yml deleted file mode 100644 index 08b3d90..0000000 --- a/modules/55-processes/40-tasks-and-agents/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Tasks and agents -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/55-processes/40-tasks-and-agents/description.ru.yml b/modules/55-processes/40-tasks-and-agents/description.ru.yml deleted file mode 100644 index dec888c..0000000 --- a/modules/55-processes/40-tasks-and-agents/description.ru.yml +++ /dev/null @@ -1,160 +0,0 @@ ---- -name: Задачи и агенты -theory: | - - Для упрощения работы с процессами, в Elixir есть модули `Task` и `Agent`. Для начала познакомимся с `Task`. - - Преимущества модуля `Task` в отличие от создания процессов напрямую через `spawn` заключаются в улучшенном выводе ошибок, а так же соответствующим API для обработки таких *задач*: - - ```elixir - Task.start(fn -> raise "boom" end) - # => {:ok, #PID<0.8444.0>} - - # => 16:20:15.164 [error] Task #PID<0.8444.0> started from #PID<0.105.0> terminating - # => ** (RuntimeError) boom - # => iex:368: (file) - # => (elixir 1.15.0) src/elixir.erl:374: anonymous fn/4 in :elixir.eval_external_handler/1 - # => Function: #Function<43.3316493/0 in :erl_eval.expr/6> - # => Args: [] - - Task.start_link(fn -> raise "boom" end) - # => {:ok, #PID<0.8446.0>} - # проверим и очистим почтовый ящик процесса - flush() - # => {:EXIT, #PID<0.8446.0>, - # => {%RuntimeError{message: "boom"}, - # => [ - # => {:elixir_eval, :__FILE__, 1, [file: ~c"iex", line: 372]}, - # => {:elixir, :"-eval_external_handler/1-fun-2-", 4, - # => [file: ~c"src/elixir.erl", line: 374, error_info: %{module: Exception}]} - # => ]}} - ``` - - Помимо улучшенного отчета об ошибке в модуле `Task` есть API для асинхронной обработки задач с помощью функций `Task.async()` и `Task.await()`: - - ```elixir - tasks = 0..5 |> Enum.map(fn x -> Task.async(fn -> x * 2 end) end) - # => [ - # => %Task{ - # => mfa: {:erlang, :apply, 2}, - # => owner: #PID<0.105.0>, - # => pid: #PID<0.8447.0>, - # => ref: #Reference<0.73723457.2325282820.199341> - # => }, - # => %Task{ - # => mfa: {:erlang, :apply, 2}, - # => owner: #PID<0.105.0>, - # => pid: #PID<0.8448.0>, - # => ref: #Reference<0.73723457.2325282820.199342> - # => }, - # => ......... - # => ] - - tasks |> Enum.map(fn task -> Task.await(task) end) - # => [0, 2, 4, 6, 8, 10] - ``` - - В модуле есть и [другие функции](https://hexdocs.pm/elixir/Task.html), с которыми потом можно самостоятельно ознакомиться. - - Теперь рассмотрим модуль `Agent` подробнее. Если нужно создать процесс, который хранит состояние и это состояние необходимо передавать другим процессам или состояние используется одним процессом в течении некоторого времени - в этом случае подходит `Agent`. Примеры: - - ```elixir - defmodule Counter do - use Agent - - def start_link(initial_state \\ 0) do - Agent.start_link(fn -> initial_state end, name: __MODULE__) - end - - def current_value do - Agent.get(__MODULE__, fn state -> state end) - end - - def inc do - Agent.update(__MODULE__, fn state -> state + 1 end) - end - - def dec do - Agent.update(__MODULE__, fn state -> state - 1 end) - end - end - - Counter.start_link(2) - # => {:ok, #PID<0.115.0>} - - Counter.current_value() - # => 2 - - Counter.inc() - # => :ok - Counter.current_value() - # => 3 - - Counter.dec() - # => ok - Counter.current_value() - # => 2 - ``` - - Так как агент запущен в отдельном процессе, счетчик может безопасно изменяться при конкурентной обработке. - - В функции `start_link` происходит *глобальная* регистрация процесса-агента и его связывание с процессом из которого вызвана функция, подобно функции `spawn_link`. Про регистрацию процессов будет рассказано в следующих упражнениях. - - В функции `current_value` происходит обращение к внутреннему состоянию процесса и возврат этого состояния наружу. - - В функциях `inc` и `dec` изменяется состояние процесса-агента, увеличиваясь или уменьшаясь на единицу соответственно. - - Модуль `Agent` предполагает разделение на клиентскую и серверную часть. Функции, переданные в качестве аргументов для модуля `Agent` вызываются внутри агента (серверная часть). В ином случае вызов кода считается клиентской частью. Рассмотрим подробнее на примере: - - ```elixir - # вычисление произойдет на стороне процесс-агента, то есть на серверной части - def do_something(agent) do - Agent.get(agent, fn state -> run_slow_code(state) end) - end - - # вычисление произойдет на стороне процесса, вызвавшего функцию, то есть на клиентской части - def do_something(agent) do - Agent.get(agent, fn state -> state end) |> run_slow_code() - end - ``` - - Первая функция блокирует работу агента. Вторая функция копирует все состояние на клиента и затем выполняет операцию на клиенте. При этом следует учитывать, достаточно ли велики данные, чтобы выполнить их обработку на сервере, или их можно быстро переслать клиенту. Другой фактор - нужно ли обрабатывать данные атомарно: получение состояния и вызов run_slow_code(state) вне агента означает, что состояние агента может быть обновлено в это время. Это особенно важно в случае обновлений, поскольку вычисление нового состояния на клиенте, а не на сервере может привести к условиям гонки, если несколько клиентов будут пытаться обновить одно и то же состояние на разные значения. - - В модуле `Agent` есть и [другие функции](https://hexdocs.pm/elixir/Agent.html), которые потом можно самостоятельно изучить. - - После объявления модуля агента, в нем еще появляется функция `child_spec/1`, про ее смысл поговорим дальше, в рамках дерева супервизии процессов. - -instructions: | - - В этот раз допишите функции агента `Accumulator`, используя модуль `Task` и опираясь на модуль `Calculator`: - - `add` прибавить к состоянию аккумулятора переданное число; - - `sub` вычесть состояние аккумулятора на переданное число; - - `mul` умножить состояние аккумулятора на переданное число; - - `div` разделить состояние аккумулятора на переданное число; - - `reset` сбрасывает состояние `Accumulator` в ноль; - - `current` возвращает нынешнее состояние `Accumulator`. - - ```elixir - Accumulator.start_link(0) - - Accumulator.add(10) # => :ok - Accumulator.current() # => 10 - - Accumulator.sub(2) # => :ok - Accumulator.current() # => 8 - - Accumulator.mul(2) # => :ok - Accumulator.current() # => 16 - - Accumulator.div(4) # => :ok - Accumulator.current() # => 4 - - Accumulator.reset() # => :ok - Accumulator.current() # => 0 - ``` - -tips: - - | - [Официальная документация Agent](https://hexdocs.pm/elixir/Agent.html) - - | - [Официальная документация Task](https://hexdocs.pm/elixir/Task.html) diff --git a/modules/55-processes/40-tasks-and-agents/en/data.yml b/modules/55-processes/40-tasks-and-agents/en/data.yml index 75b0984..645bd74 100644 --- a/modules/55-processes/40-tasks-and-agents/en/data.yml +++ b/modules/55-processes/40-tasks-and-agents/en/data.yml @@ -1,2 +1,3 @@ +--- name: Tasks and agents tips: [] diff --git a/modules/55-processes/40-tasks-and-agents/ru/data.yml b/modules/55-processes/40-tasks-and-agents/ru/data.yml index 1baf822..deda6cf 100644 --- a/modules/55-processes/40-tasks-and-agents/ru/data.yml +++ b/modules/55-processes/40-tasks-and-agents/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Задачи и агенты tips: - | diff --git a/modules/55-processes/50-supervisors/description.en.yml b/modules/55-processes/50-supervisors/description.en.yml deleted file mode 100644 index 00dd442..0000000 --- a/modules/55-processes/50-supervisors/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Supervisors -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/55-processes/50-supervisors/description.ru.yml b/modules/55-processes/50-supervisors/description.ru.yml deleted file mode 100644 index be60eaa..0000000 --- a/modules/55-processes/50-supervisors/description.ru.yml +++ /dev/null @@ -1,180 +0,0 @@ ---- -name: Супервизоры -theory: | - - Супервизоры - процессы которые следят за жизненным циклом других процессов (потомков). Благодаря супервизорам появляется возможность выстраивать внутри приложения специальную иерархическую структуру, называемую *деревом супервизии*. Дерево супервизии позволяет выстраивать отказоустойчивы приложения, логика обработки и перезапуска процессов в котором скрыта от пользователя приложения. - - Супервизоры, как и дерево супервизии, являются частью OTP Erlang (Open Telecom Platform) - набором библиотек и подходов для упрощения работы с процессами. Далее по модулю мы познакомимся еще с одной важной сущностью OTP, помимо дерева супервизии и супервизоров. - - Для запуска супервизора нужно передать ему список потомков с их спецификацией через функцию `start_link`. Либо реализовать модуль с функциями обратного вызова, соответствующих поведению `Supervisor`. Теперь создадим агента-счетчик, который передадим под наблюдение: - - ```elixir - defmodule Counter do - use Agent - - def start_link(initial_state \\ 0) do - Agent.start_link(fn -> initial_state end, name: __MODULE__) - end - - def current_value do - Agent.get(__MODULE__, fn state -> state end) - end - - def inc do - Agent.update(__MODULE__, fn state -> state + 1 end) - end - - def dec do - Agent.update(__MODULE__, fn state -> state - 1 end) - end - - def boom do - raise "boom" - end - end - ``` - - При использовании поведения `Agent`, в модуль добавилась функция `child_spec/1`. Она и нужна для запуска агента через супервизора. У сгенерированной функции арность 1, для того, чтобы передать начальное состояние при инициализации агента. Вызовем эту функцию: - - ```elixir - Counter.child_spec(0) - # => %{id: Counter, start: {Counter, :start_link, [0]}} - - Counter.child_spec(5) - # => %{id: Counter, start: {Counter, :start_link, [5]}} - ``` - - Как видно из примеров, `child_spec/1` всего лишь возвращает словарь с конфигурацией процесса, идентификатором процесса выступает его модуль, под ключом `:start` находится информация о том, как запускать процесс. Перевести эту спецификацию можно следующим образом: в первом вызове `child_spec/1` процесс нужно запустить `Counter.start_link(0)`, во втором случае `Counter.start_link(5)`. - - Идея в том, что при запуске супервизору нужно передать список наблюдаемых процессов, в которых содержится кортеж с названием модулей и его начальным состоянием. А теперь запустим супервизора для наблюдения за агентом: - - ```elixir - children = [ - {Counter, 0} - ] - - {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_all) - pid - # => #PID<0.127.0> - ``` - - Создался процесс-супервизор, который запустил агента и отслеживает его состояние. Можно и не указывать начальное состояние, передав список потомков без кортежей: - - ```elixir - children = [Counter] - - {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_all) - # => #PID<0.129.0> - ``` - - Однако в таком случае, в `start_link/1` агента передастся пустой список: - - ```elixir - defmodule Counter do - use Agent - - def start_link(initial_state \\ 0) do - IO.inspect(initial_state) - Agent.start_link(fn -> initial_state end, name: __MODULE__) - end - end - - children = [Counter] - - {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_all) - # => [] - # => #PID<0.131.0> - ``` - - В таких случаях нужно переписать инициализацию процесса таким образом: - - ```elixir - def start_link(opts) do - {initial_value, opts} = Keyword.pop(opts, :initial_value, 0) - Agent.start_link(fn -> initial_value end, opts) - end - ``` - - Теперь, когда процесс запущен, можно получить служебную информацию о супервизоре с помощью `count_children` и `which_children`, а так же пользоваться агентом по прямому назначению: - - ```elixir - {:ok, pid} = Supervisor.start_link([{Counter, 0}], strategy: :one_for_all) - - Supervisor.count_children(pid) - # => %{active: 1, workers: 1, supervisors: 0, specs: 1} - - Counter.inc() - Counter.inc() - Counter.current_value() - # => 2 - - Supervisor.which_children(pid) - # => [{Counter, #PID<0.146.0>, :worker, [Counter]}] - ``` - - Рассмотрим запуск супервизора `Supervisor.start_link(children, strategy: :one_for_all)`, а конкретно `strategy: :one_for_all`. Эта опция является стратегией перезапуска процессов которые завершились аварийно. Таких стратегий перезапуска несколько: - - `:one_for_one` - если потомок-процесс аварийно завершился, то только этот процесс и будет перезапущен; - - `:one_for_all` - если один из потомков аварийно завершился, то *все* дочерние процессы супервизора завершатся и перезапустятся; - - `:rest_for_one` - если один из потомков аварийно завершился, то только этот процесс и все следующие за ним потомки завершатся и перезапустятся. - - Зачастую используются стратегии `:one_for_one` и `:rest_for_one`. - - Помимо стратегии перезапуска, в супервизоре можно указать, каким образом завершать наблюдаемые процессы. А точнее, какой сигнал выхода отправить процессу при, например, перезапуске. Можно указать приоритет у процессов потомков, например, если есть какой-то важный процесс потомок, без которого супервизия не имеет смысла и после завершения работы этого потомка супервизор получает сигнал от этого процесса и супервизор завершает работу (process shutdown). Об этом можно подробнее почитать в [официальной документации](https://hexdocs.pm/elixir/Supervisor.html#module-supervisor-strategies-and-options). Тепрерь посмотрим на примере, как работает стратегия `:one_for_all`: - - ```elixir - {:ok, supervisor_pid} = Supervisor.start_link([{Counter, 0}], strategy: :one_for_one) - - Counter.inc() - Counter.current_value() - # => 1 - - # теперь вызовем функцию которая бросит исключение - Counter.boom() - # => ** (RuntimeError) boom - # => iex:71: Counter.boom/0 - # => iex:67: (file) - - Supervisor.count_children(supervisor_pid) - # => %{active: 1, workers: 1, supervisors: 0, specs: 1} - - Counter.current_value() - # => 0 - ``` - - Процесс `Counter` завершился с ошибкой, супервизор перехватил исключение и перезапустил процесс счетчик с начальным состоянием по умолчанию. - -instructions: | - - Супервизоры могут задаваться через модули, для этого нужно в модуле использовать поведение `Supervisor` и определить функцию обратного вызова `init/1`, которая будет вызвана при запуске супервизора через `start_link`. В файле с решением описано два агента, ваша задача дописать модуль `Solution`, добавив две функции: - - `start_link` - функция для запуска супервизора из модуля - - `init` - функция, которая запустится перед стартом супервизора, в котором указывается список потомков, стратегия перезапуска и т.д. - - В функции `init` сделайте потомками `Decrementor` и `Incrementor`, а в стратегии перезапуска укажите `:one_for_one`. - - ```elixir - {:ok, _} = Solution.start_link() - - Supervisor.which_children(Solution) - # => [ - # => {Decrementor, #PID<0.196.0>, :worker, [Decrementor]}, - # => {Incrementor, #PID<0.195.0>, :worker, [Incrementor]} - # => ] - - Supervisor.count_children(Solution) - # => %{active: 2, workers: 2, supervisors: 0, specs: 2} - - Incrementor.run() - Incrementor.current_value() - # => 1 - - Decrementor.current_value() - # => 0 - ``` - -tips: - - | - [Официальная документация Supervisor](https://hexdocs.pm/elixir/Supervisor.html) - - | - [Про дерево супервизии в Erlang](https://erlang.org/documentation/doc-4.9.1/doc/design_principles/sup_princ.html) - - | - [Пример модуля супервизора](https://hexdocs.pm/elixir/Supervisor.html#module-module-based-supervisors) diff --git a/modules/55-processes/50-supervisors/en/data.yml b/modules/55-processes/50-supervisors/en/data.yml index 0d3086f..d80f380 100644 --- a/modules/55-processes/50-supervisors/en/data.yml +++ b/modules/55-processes/50-supervisors/en/data.yml @@ -1,2 +1,3 @@ +--- name: Supervisors tips: [] diff --git a/modules/55-processes/50-supervisors/ru/data.yml b/modules/55-processes/50-supervisors/ru/data.yml index 1fea043..e5e5999 100644 --- a/modules/55-processes/50-supervisors/ru/data.yml +++ b/modules/55-processes/50-supervisors/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Супервизоры tips: - > diff --git a/modules/55-processes/55-process-registration/description.en.yml b/modules/55-processes/55-process-registration/description.en.yml deleted file mode 100644 index 0051f78..0000000 --- a/modules/55-processes/55-process-registration/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Process registration -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/55-processes/55-process-registration/description.ru.yml b/modules/55-processes/55-process-registration/description.ru.yml deleted file mode 100644 index cc35f3d..0000000 --- a/modules/55-processes/55-process-registration/description.ru.yml +++ /dev/null @@ -1,181 +0,0 @@ ---- -name: Регистрация процессов -theory: | - - Функция `spawn`, при вызове, возвращает идентификатор процесса: - - ```elixir - spawn(fn -> 2 + 2 end) - # => #PID<0.197.0> - ``` - - Однако, если процесс создается не напрямую, например через супервизора, то у программиста "пропадает" доступ к идентификатору процесса. Для таких случаев используется регистрация процессов. Вспомним код агента-счетчика из прошлых упражнений: - - ```elixir - defmodule Counter do - use Agent - - def start_link(initial_state \\ 0) do - Agent.start_link(fn -> initial_state end, name: __MODULE__) - end - - def current_value, do: Agent.get(__MODULE__, fn state -> state end) - def inc, do: Agent.update(__MODULE__, fn state -> state + 1 end) - def dec, do: Agent.update(__MODULE__, fn state -> state - 1 end) - end - ``` - - При вызове функции `Agent.start_link`, передается опция `:name`, в которой находится название нынешнего модуля, то есть `Counter`. В итоге после создания, процесс сохраняется в локальном регистре процессов под названием модуля `Counter`: - - ```elixir - Counter.start_link() - # => {:ok, #PID<0.115.0>} - ``` - - А теперь проверим список зарегистрированных процессов: - - ```elixir - Process.registered() - # => [:user_drv, :rex, :inet_db, :elixir_code_server, :erl_prim_loader, - # => :user_drv_writer, :global_name_server, :init, :kernel_sup, :code_server, - # => :erts_code_purger, :logger_std_h_default, :logger_sup, :socket_registry, - # => IEx.Config, :user_drv_reader, :erl_signal_server, :elixir_config, IEx.Pry, - # => :file_server_2, :standard_error_sup, Logger.Supervisor, :global_group, - # => :application_controller, :kernel_safe_sup, :user, :logger_proxy, IEx.Broker, - # => :logger, :global_group_check, Counter, IEx.Supervisor, :kernel_refc, - # => :elixir_sup, :logger_handler_watcher, :standard_error] - ``` - - Как видно из списка, при запуске консоли по умолчанию регистрируется множество разных процессов, но помимо них, в списке появился `Counter`. Благодаря этому, мы теперь можем обращаться к процессу через название модуля: - - ```elixir - # найдем процесс - pid = Process.whereis(Counter) - # => #PID<0.115.0> - - # обновим состояние агента напрямую - Agent.update(pid, fn state -> state + 100 end) - # => :ok - Counter.current_value() - # => 100 - ``` - - В примере выше, не стоит обновлять состояние агента напрямую через идентификатор процесса, так как это обход абстракций. Модуль представляет отдельные функции для работы с ним, которые скрывают детали реализации, поэтому ими и нужно пользоваться. А теперь попробуем еще раз запустить процесс-счетчик: - - ```elixir - Counter.start_link() - # => {:error, {:already_started, #PID<0.115.0>}} - ``` - - Процесс уже запущен и зарегистрирован, поэтому повторное создание не требуется. Попробуем убить процесс и сделаем пару проверок: - - ```elixir - pid = Process.whereis(Counter) - Process.exit(pid, :kill) - # => ** (EXIT from #PID<0.109.0>) shell process exited with reason: killed - # => Interactive Elixir (1.15.5) - press Ctrl+C to exit (type h() ENTER for help) - - Process.registered() - # => [:user_drv, :rex, :inet_db, :elixir_code_server, :erl_prim_loader, - # => :user_drv_writer, :global_name_server, :init, :kernel_sup, :code_server, - # => :erts_code_purger, :logger_std_h_default, :logger_sup, :socket_registry, - # => IEx.Config, :user_drv_reader, :erl_signal_server, :elixir_config, IEx.Pry, - # => :file_server_2, :standard_error_sup, Logger.Supervisor, :global_group, - # => :application_controller, :kernel_safe_sup, :user, :logger_proxy, IEx.Broker, - # => :logger, :global_group_check, IEx.Supervisor, :kernel_refc, :elixir_sup, - # => :logger_handler_watcher, :standard_error] - - Counter.current_value() - # => ** (exit) exited in: GenServer.call(Counter, {:get, #Function<0.123767520/1 in Counter.current_value/0>}, 5000) - # => ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started - # => (elixir 1.15.5) lib/gen_server.ex:1063: GenServer.call/3 - # => iex:39: (file) - - Process.whereis(Counter) - # => nil - ``` - - Сначала мы отправили сигнал агенту о завершении, но так как процесс агента был связан напрямую с процессом интерактивной оболочкой, при аварийном завершении процесса агента заодно завершился процесс оболочки. Произошло это из-за того, что процесс оболочки в данном случае выступал "супервизором" относительно процесса счетчика. Однако, из-за того, что процесс оболочки тоже находится под наблюдением другого супервизора, то при аварийном завершении оболочки, супервизор перехватил ошибку и перезапустил процесс интерактивной оболочки, но не перезапустил процесс счетчика. Счетчик не был перезапущен ровно потому, что о нем было известно только процессу оболочки и никаких стратегий перезапуска для счетчика не было указано при старте интерактивной оболочки. Ровно об этом и говорит код ниже, что счетчика, как процесса, больше не существует, его нет в регистре процессов и его нельзя менять. - - В базовом случае, процессы регистрируются через `Process.register`, однако процесс при регистрации должен быть обязательно живым: - - ```elixir - # долгоживущий процесс - pid = spawn(fn -> Process.sleep(:timer.seconds(20)) end) - #PID<0.118.0> - - Process.register(pid, :my_process) - # => true - - Process.registered() - # => [..., :my_process, ...] - - # спустя 20 секунд - Process.registered() - # => [...] процесса с именем :my_process нет - - # попробуем записать быстроживущий процесс - pid = spawn(fn -> 2 + 2 end) - # => #PID<0.119.0> - - Process.register(pid, :other_process) - # => ** (ArgumentError) could not register #PID<0.119.0> with name :other_process because it is not alive, the name is already taken, or it has already been given another name - # => (elixir 1.15.5) lib/process.ex:698: Process.register(#PID<0.119.0>, :other_process) - # => iex:42: (file) - ``` - - В целом это все что необходимо знать о регистрации процессов. Если нужно регистрировать несколько одинаковых процессов под разными именами, то нужно к этому подходить с осторожностью. Например, не генерировать атомы, так как они не вычищаются сборщиком мусора и в один момент приложение переполнится по памяти. - - Если стандартного регистра процессов не хватает, то можно сделать свой, указав, к примеру, каким образом разрешать конфликты имен и как в целом хранить информацию о зарегистрированных процессах. Об этом подробнее можно почитать уже в [официальной документации](https://hexdocs.pm/elixir/Registry.html). - -instructions: | - - Допишите агента, добавив функции `add`, `drop` для регистрации/снятия процессов с учета и функцию `list_registered`, которая выводит список процессов, которые зарегистрированы через агента. Если процесс завершился, то при вызове `add` регистрировать процесс не нужно. Если удаляемый процесс не существует, то нужно вернуть `:ok`, учтите, что `Process.unregister` вызывает исключение при попытке удалить несуществующий процесс. - - ```elixir - ProcessRegister.start_link() - # => {:ok, #PID<0.139.0>} - - ProcessRegister.list_registered() - # => %{} - - pid = spawn(fn -> Process.sleep(:timer.seconds(30)) end) - ProcessRegister.add(pid, :timeout_process) - # => :ok - pid = spawn(fn -> Process.sleep(:timer.seconds(30)) end) - ProcessRegister.add(pid, :other_timeout) - # => :ok - pid = spawn(fn -> Process.sleep(:timer.seconds(30)) end) - ProcessRegister.add(pid, :timeout) - # => :ok - - ProcessRegister.list_registered() - # => %{ - # => timeout: #PID<0.152.0>, - # => timeout_process: #PID<0.150.0>, - # => other_timeout: #PID<0.151.0> - # => } - - Process.registered() - # => [..., :timeout, :timeout_process, :other_timeout, ...] - - ProcessRegister.drop(:timeout_process) - # => :ok - ProcessRegister.list_registered() - # => %{ - # => timeout: #PID<0.152.0>, - # => other_timeout: #PID<0.151.0> - # => } - - Process.registered() - # => [..., :timeout, :other_timeout, ...] - - ProcessRegister.drop(:not_existing_process) - # => :ok - ``` - - Синхронизацию состояния агента и регистра реализовывать не нужно. - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Registry.html) diff --git a/modules/55-processes/55-process-registration/en/data.yml b/modules/55-processes/55-process-registration/en/data.yml index be05150..27bccbd 100644 --- a/modules/55-processes/55-process-registration/en/data.yml +++ b/modules/55-processes/55-process-registration/en/data.yml @@ -1,2 +1,3 @@ +--- name: Process registration tips: [] diff --git a/modules/55-processes/55-process-registration/ru/data.yml b/modules/55-processes/55-process-registration/ru/data.yml index d1f94ac..26694a3 100644 --- a/modules/55-processes/55-process-registration/ru/data.yml +++ b/modules/55-processes/55-process-registration/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Регистрация процессов tips: - | diff --git a/modules/55-processes/60-genservers/description.en.yml b/modules/55-processes/60-genservers/description.en.yml deleted file mode 100644 index 8e81d16..0000000 --- a/modules/55-processes/60-genservers/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Genservers -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/55-processes/60-genservers/description.ru.yml b/modules/55-processes/60-genservers/description.ru.yml deleted file mode 100644 index 4b1cde2..0000000 --- a/modules/55-processes/60-genservers/description.ru.yml +++ /dev/null @@ -1,249 +0,0 @@ ---- -name: Генсерверы -theory: | - - Генсерверы являются основным строительным кирпичиком OTP. Генсервер - это процесс, который может хранить состояние, выполнять какой-либо код, не обязательно синхронно и т.д. Отличие обычных процессов от обобщенных серверных процессов (general servers) в том, что разработчики OTP заранее подготовили все необходимое, что зачастую нужно для работы с процессом. Например, обработка ошибок, написание функций обратного вызова, встраивание в дерево супервизии. - - Возникает вопрос, а в чем разница между `Agent` и `GenServer`, ведь с первого взгляда они делают одно и то же. Разница в том, что абстракция `Agent` построена на основе `GenServer`, например в `Agent` управление состоянием происходит через функцию `Agent.update`, в то время как у `GenServer` состоянием нужно управлять вручную. Абстракция агентов построена вокруг какого-либо *состояния*, в то время как генсервер может и не обладать состоянием, а только выполнять какую-либо работу. - - На самом деле, в первых упражнениях мы уже написали некоторое подобие генсервера, которое работает по схеме: - - ```text - _______________ _____________ - |client module| <-> |server call| - --------------- ------------- - ^ - | - v - __________________ _____________ - |server callbacks| <-> |server loop| - ------------------ ------------- - ``` - - Модуль клиент и вызов сервера работают в потоке клиента, цикл сервера и его функции обратного вызова работают в потоке сервера. По сути так и работает генсервер. Теперь рассмотрим, как будет выглядеть счетчик генсервер: - - ```elixir - defmodule Counter do - use GenServer - - def init(initial_state \\ 0) do - {:ok, initial_state} - end - - def current, do: GenServer.call(__MODULE__, :current) - def inc, do: GenServer.cast(__MODULE__, :inc) - def dec, do: GenServer.cast(__MODULE__, :dec) - - def handle_call(:current, _from, state) do - {:reply, state, state} - end - - def handle_cast(:inc, state) do - {:noreply, state + 1} - end - - def handle_cast(:dec, state) do - {:noreply, state - 1} - end - end - ``` - - И проверим счетчик в работе: - - ```elixir - # создаем и регистрируем процесс генсервер - GenServer.start_link(Counter, 0, name: Counter) - # => {:ok, #PID<0.115.0>} - - Counter.current() - # => 0 - - Counter.inc() - # => :ok - Counter.inc() - # => :ok - Counter.inc() - # => :ok - Counter.current() - # => 3 - - Counter.dec() - # => :ok - Counter.dec() - # => :ok - Counter.current() - # => 1 - ``` - - Как и в случае с агентами, внутри генсервера мы описываем функции для клиентской части и серверной, вызов серверной части происходит во время обработки сообщения процесса генсервера, а конкретнее в функциях обратного вызова `handle_call`, `handle_cast` и `handle_info`. Эти функции действую следующим образом: - - `handle_call` - синхронный обработчик сообщения, когда клиенту важен ответ от сервера и он блокируется, в ожидании оного; - - `handle_cast` - асинхронный обработчик сообщения, когда клиент не хочет блокироваться и ждать ответа от сервера; - - `handle_info` - низкоуровневый асинхронный обработчик, срабатывает когда сообщение серверу передается напрямую, а не через `GenServer.call`, `GenServer.cast`. Зачастую используется для внутренних задач генсервера, например по таймеру обнулять состояние генсервера или сделать http вызов. Еще можно использовать этот обработчик в качестве мониторинга за другим процессом через обработку сообщения `:DOWN`. - - Так как `GenServer` является поведением, то мы можем перед описанием функции обратного вызова добавить аттрибут `@impl true`. Это позволит компилятору проверить сигнатуры описанных функций и что необходимые функции вообще реализованы. Подробнее про возвращаемые значения для функций обратных вызовов можно посмотреть в [официальной документации](https://hexdocs.pm/elixir/GenServer.html#c:handle_cast/2), либо в интерактивной консоли ввести следующую команду: - - ```elixir - iex(48)> b GenServer - @callback code_change(old_vsn, state :: term(), extra :: term()) :: - {:ok, new_state :: term()} | {:error, reason :: term()} - when old_vsn: term() | {:down, term()} - - @callback format_status(reason, pdict_and_state :: list()) :: term() - when reason: :normal | :terminate - - @callback handle_call(request :: term(), from(), state :: term()) :: - {:reply, reply, new_state} - | {:reply, reply, new_state, - timeout() | :hibernate | {:continue, continue_arg :: term()}} - | {:noreply, new_state} - | {:noreply, new_state, - timeout() | :hibernate | {:continue, continue_arg :: term()}} - | {:stop, reason, reply, new_state} - | {:stop, reason, new_state} - when reply: term(), new_state: term(), reason: term() - # .............. - ``` - - Важно понимать, что обработчики `handle_call`, `handle_cast` и `handle_info` при определении завязываются на конкретные сообщения, которые они обрабатывают, поэтому важно описать паттерн catch all, который перехватит сообщения, которые генсервер не знает как обработать. Если же не описать обобщенный вариант обработки сообщения, то процесс генсервер аварийно завершится при таком вызове: - - ```elixir - GenServer.call(Counter, :do_something_different) - # => 15:30:36.108 [error] GenServer Counter terminating - # => ** (FunctionClauseError) no function clause matching in Counter.handle_call/3 - # => iex:12: Counter.handle_call(:do_something_different, {#PID<0.109.0>, [:alias | #Reference<0.0.13955.4010078260.1056243713.84046>]}, 0) - # => (stdlib 5.0.2) gen_server.erl:1113: :gen_server.try_handle_call/4 - # => (stdlib 5.0.2) gen_server.erl:1142: :gen_server.handle_msg/6 - # => (stdlib 5.0.2) proc_lib.erl:241: :proc_lib.init_p_do_apply/3 - ``` - - Поэтому допишем общие обработчики, которые перехватят любое сообщение: - - ```elixir - defmodule Counter do - use GenServer - - def init(initial_state \\ 0) do - {:ok, initial_state} - end - - # other code... - @impl true - def handle_call(msg, _from, state) do - IO.puts("handle_call intercept unknown message: #{inspect(msg)}") - {:reply, {:error, :unknown_msg}, state} - end - - @impl true - def handle_cast(msg, state) do - IO.puts("handle_cast intercept unknown message: #{inspect(msg)}") - {:noreply, state} - end - end - ``` - - Теперь проверим в работе: - - ```elixir - GenServer.call(Counter, :some) - # => handle_call intercept unknown message: :some - # => {:error, :unknown_msg} - - GenServer.cast(Counter, :some) - # => handle_cast intercept unknown message: :some - # => :ok - - GenServer.call(Counter, :current) - # => 0 - ``` - - В случае с `handle_info` нет необходимости отдельно прописывать функцию обратного вызова, так как она добавляется при вызове `use GenServer`: - - ```elixir - send(Counter, :my_msg) - # => :my_msg - # => 15:57:56.871 [error] Counter Counter received unexpected message in handle_info/2: :my_msg - # однако процесс не завершился - - Process.alive?(Process.whereis(Counter)) - # => true - ``` - - Помимо предотвращения аварийных ситуаций, общий шаблон обработки сообщений не позволит почтовому ящику генсервера переполнится, так как в BEAM нет никаких ограничений на количество сообщений в ящике процесса. А сообщения, под которые нет общих обработчиков продолжат висеть в очереди почтового ящика до тех пор, пока память не переполнится и не сработает OOM-killer операционной системы, который аварийно завершит весь узел BEAM. Однако, иногда переполнение может возникнуть из-за медленной скорости обработки сообщений, в таких случаях используют пул генсерверов, которые будут вести обработку сообщений параллельно. - - Есть еще обработчик `terminate`, он срабатывает при завершении генсервера, например, в этом обработчике можно подчистить какие-либо ресурсы или что-то логгировать. Однако этот обработчик используется редко и вызывается он если только пометить процесс генсервера как системный, то есть через `Process.flag(:trap_exit, true)`. В целом, если нет какой-либо острой нужды в сохранении состояния или освобождения ресурсов после завершения процесса, то использовать этот обработчик нет необходимости. - - Мы рассмотрели необходимый минимум, чтобы понимать, что такое процессы в Elixir экосистеме, что такое OTP и как все это использовать. Познакомились с абстракциями `Supervisor`, `GenServer`, `Agent` и узнали о дереве супервизии. Для еще лучшего понимания, какие идеи стоят за процессами, стоит почитать про акторную модель и историю языка Erlang. - -instructions: | - - В файле с решением описана инициализация генсервера-кеша, ваша задача дописать модуль `Solution`, добавив следующие функции: - - `add/2` - функция добавляющая в кеш ключ-значение, асинхронная; - - `drop/1` - функция, удаляющая из кеша значение по переданному ключу, асинхронная; - - `reset/0` - функция, сбрасывающая состояние генсервера, асинхронная; - - `current_state/0` - функция, возвращающая состояние генсервера, синхронная; - - `has?/1` - функция, проверяющая, есть ли переданный ключ в состоянии генсервера, синхронная. - - Если не понятно, использовать `handle_cast` или `handle_call`, то изучите семантику реализуемых функций, нужен ли ответ от генсервера или нет. - - ```elixir - Solution.start_link() - # => {:ok, #PID<0.121.0>} - - Solution.current_state() - # => %{} - - Solution.add(:my_key, "value") - # => :ok - - Solution.current_state() - # => %{my_key: "value"} - - Solution.has?(:my_key) - # => true - - Solution.has?(:other_key) - # => false - - Solution.drop(:not_existing_key) - # => :ok - - Solution.current_state() - # => %{my_key: "value"} - - Solution.drop(:my_key) - # => :ok - - Solution.current_state() - # => %{} - - 1..10 |> Enum.each(&(Solution.add("key_#{&1}", "value_#{&1}"))) - - Solution.current_state() - # => %{ - # => "key_1" => "value_1", - # => "key_10" => "value_10", - # => "key_2" => "value_2", - # => "key_3" => "value_3", - # => "key_4" => "value_4", - # => "key_5" => "value_5", - # => "key_6" => "value_6", - # => "key_7" => "value_7", - # => "key_8" => "value_8", - # => "key_9" => "value_9" - # => } - - Solution.reset() - # => :ok - Solution.current_state() - # => %{} - ``` - -tips: - - | - [Официальная документация GenServer](https://hexdocs.pm/elixir/GenServer.html) - - | - [Акторная модель](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2#:~:text=%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C%20%D0%B0%CC%81%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2%20%E2%80%94%20%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F%20%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C%20%D0%BF%D0%B0%D1%80%D0%B0%D0%BB%D0%BB%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D1%85,%D1%81%D1%87%D0%B8%D1%82%D0%B0%D1%8E%D1%89%D0%B5%D0%B3%D0%BE%D1%81%D1%8F%20%D1%83%D0%BD%D0%B8%D0%B2%D0%B5%D1%80%D1%81%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%BC%20%D0%BF%D1%80%D0%B8%D0%BC%D0%B8%D1%82%D0%B8%D0%B2%D0%BE%D0%BC%20%D0%BF%D0%B0%D1%80%D0%B0%D0%BB%D0%BB%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F.) - - | - [История Erlang](https://habr.com/ru/companies/ruvds/articles/749192/) - - | - [Цитаты Джо Армстронга, создателя Erlang](https://habr.com/ru/articles/508696/) diff --git a/modules/55-processes/60-genservers/en/data.yml b/modules/55-processes/60-genservers/en/data.yml index 2ed84c9..d868836 100644 --- a/modules/55-processes/60-genservers/en/data.yml +++ b/modules/55-processes/60-genservers/en/data.yml @@ -1,2 +1,3 @@ +--- name: Genservers tips: [] diff --git a/modules/55-processes/60-genservers/ru/data.yml b/modules/55-processes/60-genservers/ru/data.yml index 4d69670..3b96c91 100644 --- a/modules/55-processes/60-genservers/ru/data.yml +++ b/modules/55-processes/60-genservers/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Генсерверы tips: - > diff --git a/modules/60-macros/10-macros-intro/description.en.yml b/modules/60-macros/10-macros-intro/description.en.yml deleted file mode 100644 index 9a5429c..0000000 --- a/modules/60-macros/10-macros-intro/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Intoduction to macros -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/60-macros/10-macros-intro/description.ru.yml b/modules/60-macros/10-macros-intro/description.ru.yml deleted file mode 100644 index 90c2ef6..0000000 --- a/modules/60-macros/10-macros-intro/description.ru.yml +++ /dev/null @@ -1,88 +0,0 @@ ---- -name: Знакомство с макросами -theory: | - - Иногда возникает необходимость расширить сам язык, создав предметно-ориентированный язык (DSL), либо реализовать какие-то новые возможности. Elixir с помощью макросов позволяет достичь этого, а сам процесс написания макросов называется метапрограммированием. - - Макросы похожи на функции, но действуют совершенно иначе, чем функции. Объявляется макрос с помощью инструкции `defmacro`. Для начала рассмотрим отличия макросов и функций: - - ```elixir - # объявим модуль с функцией и макросом - defmodule Exercise do - def my_fn(x) do - IO.inspect(x) - x - end - - defmacro my_macro(x) do - IO.inspect(x) - x - end - end - ``` - - Чтобы воспользоваться макросом, нужно подключить модуль с помощью инструкции `require` в котором макрос объявлен: - - ```elixir - require Exercise - - Exercise.my_fn(1 + 2) - # => 3 - # => 3 - - Exercise.my_macro(1 + 2) - # => {:+, [line: 12], [1, 2]} - # => 3 - ``` - - Вызов функции понятен, Elixir вычисляет значение выражения `1 + 2`, затем передает его дальше в функцию, где полученное значение выводится на экран и возвращается из функции. В случае с макросом, вместо вычисления выражения, оно интерпретируется как кортеж, затем этот кортеж выводится на экран и возвращается из макроса, а после интерпретатор Elixir вычисляет возвращенный кортеж. - - Рассмотрим внимательнее кортеж, который оказался в макросе `{:+, [line: 12], [1, 2]}`, где `:+` - оператор, `[line: 12]` - метаданные об операции, `[1, 2]` - список операндов. Теперь, обладая пониманием, что означает этот кортеж, напишем макрос, который удваивает переданный аргумент: - - ```elixir - defmodule Exercise do - defmacro double(x) do - {:*, [], [2, x]} - end - end - - require Exercise - - Exercise.double(2) - # => 4 - Exercise.double(10) - # => 20 - Exercise.double(2 * 2) - # => 8 - Exercise.double(2 + 1 - 5) - # => -4 - ``` - - Макрос работает, но выглядит неудобно, в следующем упражнении рассмотрим как сделать макрос более читаемым. - - Интересный факт: создатель языка, Жозе Валим, при добавлении макросов в Elixir, вдохновлялся Clojure. - -instructions: | - - Создайте макрос `my_abs`, который берет абсолютное значение переданного аргумента (поможет функция `abs`): - - ```elixir - require Solution - - Solution.my_abs(-2) - # => 2 - Solution.my_abs(2) - # => 2 - Solution.my_abs(-5 * 100) - # => 500 - Solution.my_abs(-2 - 100 + 1) - # => 101 - ``` - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Macro.html) - - | - [Про DSL](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B4%D0%BC%D0%B5%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA) - - | - [Про метапрограммирование](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%B0%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) diff --git a/modules/60-macros/10-macros-intro/en/data.yml b/modules/60-macros/10-macros-intro/en/data.yml index 3636fe8..b3042af 100644 --- a/modules/60-macros/10-macros-intro/en/data.yml +++ b/modules/60-macros/10-macros-intro/en/data.yml @@ -1,2 +1,3 @@ +--- name: Intoduction to macros tips: [] diff --git a/modules/60-macros/10-macros-intro/ru/data.yml b/modules/60-macros/10-macros-intro/ru/data.yml index 7d9a6c6..2a0ed7b 100644 --- a/modules/60-macros/10-macros-intro/ru/data.yml +++ b/modules/60-macros/10-macros-intro/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Знакомство с макросами tips: - | diff --git a/modules/60-macros/20-quoting/description.en.yml b/modules/60-macros/20-quoting/description.en.yml deleted file mode 100644 index 65fb2a2..0000000 --- a/modules/60-macros/20-quoting/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Intoduction to quote and unquote -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/60-macros/20-quoting/description.ru.yml b/modules/60-macros/20-quoting/description.ru.yml deleted file mode 100644 index ff4cd02..0000000 --- a/modules/60-macros/20-quoting/description.ru.yml +++ /dev/null @@ -1,136 +0,0 @@ ---- -name: Знакомство с quote и unquote -theory: | - - Вспомним пример из прошлого упражнения: - - ```elixir - defmodule Exercise do - defmacro double(x) do - {:*, [], [2, x]} - end - end - ``` - - В этом макросе мы вернули код во `внутреннем представлении` языка Elixir, но работать с таким представлением неудобно, особенно если есть вложенность: - - ```elixir - # в этом макросе выполняется следующая операция ((x * 4) + 3) * x - defmodule Exercise do - defmacro magic(x) do - {:*, [], - [ - {:+, [], - [{:*, [], [x, 4]}, 3]}, - x - ] - } - end - end - - require Exercise - - Exercise.magic(1) - # 7, т.к. ((1 * 4) + 3) * 1 - Exercise.magic(2) - # 22, т.к. ((2 * 4) + 3) * 2 - ``` - - В примере выше мы напрямую управляли структурой AST дерева, однако понимать этот код стало сложнее. Для упрощения работы с AST в макросах Elixir есть функции `quote` и `unquote` прямиком перекочевавшие из Lisp-подобных языков. - - Функция `quote` принимает произвольное выражение на языке Elixir и преобразует его во внутренне представление языка: - - ```elixir - quote do: 1 + 2 - # => {:+, [], [1, 2]} - - quote do: Integer.to_string((1 + 2) * 3) - # => {{:., [], []}, [], - # => [ - # => {:*, [], - # => [{:+, [], [1, 2]}, 3]} - # => ]} - ``` - - Теперь попробуем переписать макрос из начала упражнения: - - ```elixir - defmodule Exercise do - defmacro double(x) do - quote do: 2 * x - end - end - - require Exercise - - Exercise.double(2) - # => error: undefined variable "x" (context Exercise) - ``` - - Код не работает из-за того, что `x` при передаче в макрос уже в форме внутреннего представления, поэтому нужно сообщить Elixir, что аргумент не нужно переводить во внутренне представление, для этого используется функция `unquote`: - - ```elixir - defmodule Exercise do - defmacro double(x) do - quote do - 2 * unquote(x) - end - end - end - - require Exercise - - Exercise.double(2) - # => 4 - ``` - - По сути мы сообщили Elixir следующее: `Преврати 2 * x во внутреннее представление, но оставь аргумент x в исходном виде.` - - Подведем итоги: `quote` означает `преврати все в блоке do в формат внутреннего представления`, `unquote` означает `не превращай это во внутренний формат`. - - Многие, кто пишут макросы, частно допускают ошибку, забывая передать аргументы функции `unquote`. Важно помнить, что *все* аргументы передаются макросам во внутреннем формате. - - Так же важно знать, что при передаче в `quote` атома, числа, строки, списка или кортежа с двумя элементами, функция вернет аргумент без изменений, а не кортеж во внутреннем формате. - - ```elixir - quote do: :a - # => :a - quote do: 2 - # => 2 - quote do: "hello" - # => "hello - quote do: [1, 2, 3] - # => [1, 2, 3] - - quote do: {1, 2} - # => {1, 2} - quote do: {1, 2, 3} - # => {:{}, [], [1, 2, 3]} - quote do: %{a: 2} - # => {:%{}, [], [a: 2]} - ``` - - Происходит это потому, что элементы из примера выше тоже представляют собой часть AST структуры Elixir, поэтому их не нужно дополнительно переводить во внутреннее представление. - -instructions: | - - Создайте макрос `my_unless`, который повторяет семантику `unless`: - - ```elixir - require Solution - - Solution.my_unless(false, do: 1 + 3) - # => 4 - Solution.my_unless(true, do: 1 + 3) - # => nil - Solution.my_unless(2 == 2, do: "hello") - # => nil - Solution.my_unless(2 == 1, do: "world") - # => "world" - ``` - -tips: - - | - [Официальная документация](https://hexdocs.pm/elixir/Kernel.SpecialForms.html#quote/2) - - | - [Про AST](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) diff --git a/modules/60-macros/20-quoting/en/data.yml b/modules/60-macros/20-quoting/en/data.yml index 03d6d99..b754479 100644 --- a/modules/60-macros/20-quoting/en/data.yml +++ b/modules/60-macros/20-quoting/en/data.yml @@ -1,2 +1,3 @@ +--- name: Intoduction to quote and unquote tips: [] diff --git a/modules/60-macros/20-quoting/ru/data.yml b/modules/60-macros/20-quoting/ru/data.yml index 5a20b4c..fc99015 100644 --- a/modules/60-macros/20-quoting/ru/data.yml +++ b/modules/60-macros/20-quoting/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Знакомство с quote и unquote tips: - > diff --git a/modules/60-macros/30-new-functionality/description.en.yml b/modules/60-macros/30-new-functionality/description.en.yml deleted file mode 100644 index 5098cd1..0000000 --- a/modules/60-macros/30-new-functionality/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: New functionality -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/60-macros/30-new-functionality/description.ru.yml b/modules/60-macros/30-new-functionality/description.ru.yml deleted file mode 100644 index a5f7c53..0000000 --- a/modules/60-macros/30-new-functionality/description.ru.yml +++ /dev/null @@ -1,110 +0,0 @@ ---- -name: Новые возможности -theory: | - - Макросы позволяют добавлять в язык новые команды, как в предыдущем упражнении: - - ```elixir - defmodule Solution do - defmacro my_unless(condition, do: expression) do - quote do - if(!unquote(condition), do: unquote(expression)) - end - end - end - ``` - - На самом деле, в Elixir все конструкции имеют внутреннее представление, даже функции. Это означает, что с помощью макроса можно сгенерировать функцию: - - ```elixir - defmodule Exercise do - defmacro create_multiplier(fn_name, factor) do - quote do - def unquote(fn_name)(value) do - unquote(factor) * value - end - end - end - end - ``` - - Чтобы воспользоваться этим макросом, нужно создать другой модуль, так как определение функции доступно только внутри модуля: - - ```elixir - defmodule MyModule do - require Exercise - - Exercise.create_multiplier(:double, 2) - Exercise.create_multiplier(:triple, 3) - - def run_example() do - x = double(2) - IO.puts("Two times 2 is #{x}") - end - end - - MyModule.double(5) - # => 10 - MyModule.triple(3) - # => 9 - MyModule.run_example() - # => Two times 2 is 4 - ``` - - Создадим универсальный макрос, который за один вызов создает нужное количество функций: - - ```elixir - defmodule Exercise do - defmacro create_functions(fn_list) do - Enum.map(fn_list, fn {name, factor} -> - quote do - def unquote(:"#{name}_value")(value) do - unquote(factor) * value - end - end - end) - end - end - ``` - - И теперь опробуем макрос в новом модуле: - - ```elixir - defmodule Example do - require Exercise - - Exercise.create_functions([{:double, 2}, {:triple, 3}, {:nullify, 0}]) - end - - Example.double_value(2) - # => 4 - Example.triple_value(2) - # => 6 - Example.nullify_value(2) - # => 0 - ``` - - Если нужно создать макрос только внутри модуля, то `defmacrop` то что нужно. Как и приватные функции, макрос объявленный таким образом, будет доступен только в модуле, где макрос объявлен и только во время компиляции. - -instructions: | - - Создайте макрос `prohibit_words`, генерирующий функцию `forbidden?`, в который передается список запрещенных слов и проверяется, запрещено ли слово, переданное в функцию `forbidden?`. Если передано не слово, то функция возвращает `false`: - - ```elixir - defmodule Exercise - require Solution - - Solution.prohibit_words(["hello", "world", "foo"]) - end - - Exercise.forbidden?("hello") - # => true - Exercise.forbidden?("test") - # => false - Exercise.forbidden?(1) - # => false - Exercise.forbidden?(%{hello: :world}) - # => false - ``` - -tips: [] diff --git a/modules/60-macros/30-new-functionality/en/data.yml b/modules/60-macros/30-new-functionality/en/data.yml index a332a10..f90b62a 100644 --- a/modules/60-macros/30-new-functionality/en/data.yml +++ b/modules/60-macros/30-new-functionality/en/data.yml @@ -1,2 +1,3 @@ +--- name: New functionality tips: [] diff --git a/modules/60-macros/30-new-functionality/ru/data.yml b/modules/60-macros/30-new-functionality/ru/data.yml index 925b1d3..f5d9a73 100644 --- a/modules/60-macros/30-new-functionality/ru/data.yml +++ b/modules/60-macros/30-new-functionality/ru/data.yml @@ -1,2 +1,3 @@ +--- name: Новые возможности tips: [] diff --git a/modules/60-macros/40-macros-hygiene/description.en.yml b/modules/60-macros/40-macros-hygiene/description.en.yml deleted file mode 100644 index a23589b..0000000 --- a/modules/60-macros/40-macros-hygiene/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Macros hygiene -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/60-macros/40-macros-hygiene/description.ru.yml b/modules/60-macros/40-macros-hygiene/description.ru.yml deleted file mode 100644 index ae165e1..0000000 --- a/modules/60-macros/40-macros-hygiene/description.ru.yml +++ /dev/null @@ -1,147 +0,0 @@ ---- -name: Гигиена макросов -theory: | - - При создании макросов важно соблюдать их гигиену, так как макросы, которые модифицируют окружение, могут сильно навредить. Негигиеничные макросы еще сложнее понимать и отлаживать, потому что они меняют окружение, в котором исполняется код. Для устранения таких проблем в разных языках добавлены специальные возможности по упрощению создания гигиеничных макросов, Elixir в том числе. - - По умолчанию, в Elixir макросы гигиеничны, поэтому можно не переживать за контекст, в котором макрос используется: - - ```elixir - defmodule Example do - defmacro no_interference do - quote do: a = 1 - end - end - - defmodule HygieneTest do - def run() do - require Example - a = 13 - Example.no_interference() - a - end - end - - HygieneTest.run() - # => 13 - ``` - - В примере выше, макрос не перезаписывает `a`, происходит это потому, что Elixir аннотирует переменные контекстом, в котором они объявлены: - - ```elixir - defmodule Sample do - def quoted do - quote do: x - end - end - - Sample.quoted() - #=> {:x, [line: 3], Sample} - ``` - - Благодаря аннотации, Elixir понимает к какому контексту переменные принадлежат. - - В очень редких случаях, когда иначе никак, макрос можно сделать негигиеничным, например с помощью `var!`: - - ```elixir - defmodule Example do - defmacro interference do - quote do: var!(a) = 1 - end - end - - defmodule HygieneTest do - def run() do - require Example - a = 13 - Example.interference() - a - end - end - - HygieneTest.run() - # => 1 - ``` - - Так делать можно только в *исключительных* случаях, будьте крайне осторожны. - - Иногда, нужно динамически объявить переменную, тогда воспользуемся `var`: - - ```elixir - defmodule Exercise do - defmacro initialize_to_char_count(variables) do - Enum.map(variables, fn name -> - var = Macro.var(name, nil) - length = name |> Atom.to_string |> String.length - - quote do - unquote(var) = unquote(length) - end - end) - end - - def run do - initialize_to_char_count [:red, :green, :yellow] - [red, green, yellow] - end - end - - Exercise.run() - # => [3, 4, 5] - ``` - - Обратите внимание, что передается вторым аргументом в `var`. Это контекст объявления переменной, благодаря которому пересечения переменных не произойдет, если они были объявлены ранее. - - Есть магическая структура `__ENV__`, которая хранит всю информацию о *скомпилированном* окружении, включая модули, файлы, переменные, импорты и так далее: - - ```elixir - __ENV__.module - # => nil - - __ENV__.file - # => "iex" - - __ENV__.requires - # => [Application, Exercise, IEx.Helpers, Kernel, Kernel.Typespec, Solution] - - require Integer - __ENV__.requires - # => [Application, Exercise, IEx.Helpers, Integer, Kernel, Kernel.Typespec, Solution] - ``` - - Большинство функций, которые используются в модуле `Macro`, взаимодействуют с этим окружением. - -instructions: | - - Создайте макрос `with_logging`, который принимает функцию, логгирует результат выполнения и возвращает результат. Примеры использования: - - ```elixir - defmodule Exercise - require Solution - - def run_fn(function) do - Solution.with_logging do - function - end - end - end - - Exercise.run_fn(fn -> 1 + 5 end) - # => Started execution... - # => Execution result is: 6 - # => 6 - - - Exercise.run_fn(fn -> %{hello: :world} end) - # => Started execution... - # => Execution result is: %{hello: :world} - # => %{hello: :world} - ``` - -tips: - - | - [Статья про гигиену макросов](https://en.wikipedia.org/wiki/Hygienic_macro) - - | - [Официальная документация](https://hexdocs.pm/elixir/Kernel.html#var!/2) - - | - [Официальная документация про Env](https://hexdocs.pm/elixir/Macro.Env.html) diff --git a/modules/60-macros/40-macros-hygiene/en/data.yml b/modules/60-macros/40-macros-hygiene/en/data.yml index db057d7..687f064 100644 --- a/modules/60-macros/40-macros-hygiene/en/data.yml +++ b/modules/60-macros/40-macros-hygiene/en/data.yml @@ -1,2 +1,3 @@ +--- name: Macros hygiene tips: [] diff --git a/modules/60-macros/40-macros-hygiene/ru/data.yml b/modules/60-macros/40-macros-hygiene/ru/data.yml index 51ea32e..d571e34 100644 --- a/modules/60-macros/40-macros-hygiene/ru/data.yml +++ b/modules/60-macros/40-macros-hygiene/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Гигиена макросов tips: - | diff --git a/modules/60-macros/50-macros-ast/description.en.yml b/modules/60-macros/50-macros-ast/description.en.yml deleted file mode 100644 index 6d19614..0000000 --- a/modules/60-macros/50-macros-ast/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: AST and final thoughts -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/60-macros/50-macros-ast/description.ru.yml b/modules/60-macros/50-macros-ast/description.ru.yml deleted file mode 100644 index e0a7768..0000000 --- a/modules/60-macros/50-macros-ast/description.ru.yml +++ /dev/null @@ -1,134 +0,0 @@ ---- -name: AST и подведение итогов -theory: | - - В Elixir есть функции, упрощающих работу с абстрактным синтаксическим деревом (АСТ) языка. Например: - - ```elixir - module = """ - defmodule Example do - def sum(a, b) do - a + b - end - end - """ - - {:ok, result} = Code.string_to_quoted(module) - result - # => {:defmodule, [line: 1], - # => [ - # => {:__aliases__, [line: 1], [:Example]}, - # => [ - # => do: {:def, [line: 2], - # => [ - # => {:sum, [line: 2], [{:a, [line: 2], nil}, {:b, [line: 2], nil}]}, - # => [do: {:+, [line: 3], [{:a, [line: 3], nil}, {:b, [line: 3], nil}]}] - # => ]} - # => ] - # => ]} - - quoted = quote do: 1 + 2 - - quoted |> Macro.to_string |> IO.puts - # => 1 + 2 - # => :ok - - quoted_pipe = quote do: 100 |> div(10) |> div(5) - Macro.unpipe(quoted_pipe) - # => [ - # => {100, 0}, - # => {{:div, [context: Elixir, imports: [{2, Kernel}]], [10]}, 0}, - # => {{:div, [context: Elixir, imports: [{2, Kernel}]], [5]}, 0} - # => ] - ``` - - Теперь подведем итоги модуля. Мы рассмотрели, как с помощью макросов можно расширять возможности языка и напрямую работать с АСТ. - - Однако, в большинстве случаев прибегать к макросам является плохой затеей: - - Макросы сложнее понимать; - - Макросы сложнее отлаживать; - - Макросы притягивают макросы, то есть приходится писать дополнительные обвязки-макросы. - - Перед тем как написать, задумайтесь, есть ли возможность решить задачу с помощью функции? Ответ на этот вопрос почти всегда будет - `да`. - - Хоть Elixir помогает и одновременно ограничивает разработчиков, например: - - Макросы по умолчанию гигиеничны; - - Макросы не дают возможности глобально внедрять произвольный код, то есть необходимо напрямую в *конкретном* модуле вызвать `require` или `import` нужного макроса; - - Использование макросов в коде *явно*, поэтому неожиданного поведения, как например, полного переопределения функции, за спиной у разработчика не происходит; - - Использование явных `quote` и `unqoute` тоже упрощает понимание макроса, так как сразу видно, что будет выполнено сразу, а что потом. - - Но даже эти механизмы не снимают ответственность с разработчика за написанный им код, пишите макросы ответственно и вдумчиво, и только если в этом есть острая *необходимость*! - -instructions: | - - Создайте функцию `collect_module_stats`, которая принимает строку, в которой определяется модуль и функции модуля, а затем подсчитывается статистика по функциям, которые определены. - - Для начала, изучите функцию `string_to_quoted` модуля `Code` и функцию `prewalk` из модуля `Macro`. Формат собираемой статистики представлен в примерах: - - ```elixir - new_module = """ - defmodule MyModule do - - end - """ - - Solution.collect_module_stats(new_module) - # => [] - - new_module = """ - defmodule MyModule do - def hello() do - "world" - end - end - """ - - Solution.collect_module_stats(new_module) - # => [%{arity: 0, name: :hello}] - - new_module = """ - defmodule MyModule do - def hello() do - "world" - end - - defp test(a, b) do - a + b - end - end - """ - - Solution.collect_module_stats(new_module) - # => [%{arity: 2, name: :test}, %{arity: 0, name: :hello}] - - new_module = """ - defmodule MyModule do - def hello(string) do - [string, "world"] - end - - def magic(a, b, c) do - (a + b) * c - end - - defp test(a, b) do - a + b - end - end - """ - - Solution.collect_module_stats(new_module) - # => [%{arity: 2, name: :test}, %{arity: 3, name: :magic}, %{arity: 1, name: :hello}] - ``` - -tips: - - | - [Официальная документация Code](https://hexdocs.pm/elixir/Code.html) - - | - [Официальная документация Macro](https://hexdocs.pm/elixir/Macro.html#prewalk/2) - - | - [Про AST](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) - - | - [Примеры макросов на основе ExUnit, фреймворка для тестирования](https://github.com/elixir-lang/elixir/tree/main/lib/ex_unit/lib/ex_unit) - - | - [Веб фреймворк, в котором тоже много используется метапрограммирование](https://github.com/phoenixframework/phoenix) diff --git a/modules/60-macros/50-macros-ast/en/data.yml b/modules/60-macros/50-macros-ast/en/data.yml index 0edc9ca..866d6fe 100644 --- a/modules/60-macros/50-macros-ast/en/data.yml +++ b/modules/60-macros/50-macros-ast/en/data.yml @@ -1,2 +1,3 @@ +--- name: AST and final thoughts tips: [] diff --git a/modules/60-macros/50-macros-ast/ru/data.yml b/modules/60-macros/50-macros-ast/ru/data.yml index 0630c2a..b724167 100644 --- a/modules/60-macros/50-macros-ast/ru/data.yml +++ b/modules/60-macros/50-macros-ast/ru/data.yml @@ -1,3 +1,4 @@ +--- name: AST и подведение итогов tips: - | diff --git a/modules/65-extra/10-dates-and-times/description.en.yml b/modules/65-extra/10-dates-and-times/description.en.yml deleted file mode 100644 index d537ad2..0000000 --- a/modules/65-extra/10-dates-and-times/description.en.yml +++ /dev/null @@ -1,11 +0,0 @@ ---- -name: Date and time -theory: | - - 🚧 In development - -instructions: | - - 🚧 In development - -tips: [] diff --git a/modules/65-extra/10-dates-and-times/description.ru.yml b/modules/65-extra/10-dates-and-times/description.ru.yml deleted file mode 100644 index 6f519f3..0000000 --- a/modules/65-extra/10-dates-and-times/description.ru.yml +++ /dev/null @@ -1,136 +0,0 @@ ---- -name: Даты и время -theory: | - - В Эликсире есть несколько модулей для работы с датами и временем, рассмотрим их. - - Первым в списке модуль `Time`, исходя из его названия, модуль предоставляет структуру данных и функции для работы со временем: - - ```elixir - current_time = Time.utc_now() - # => ~T[13:40:18.506292] - - current_time.hour # => 13 - current_time.minute # => 40 - current_time.second # => 18 - current_time.calendar # => Calendar.ISO - - current_time.day - # => ** (KeyError) key :day not found in: ~T[13:40:18.506292] - - Time.add(current_time, 20, :minute) - # => ~T[14:00:18.506292] - Time.add(current_time, 2, :hour) - # => ~T[15:40:18.506292] - ``` - - Второй модуль `Date`, он работает только с датами, без информации о времени: - - ```elixir - current_date = Date.utc_today() - # => ~D[2023-11-18] - - current_date.day # => 18 - current_date.month # => 11 - current_date.year # => 2023 - - Date.add(current_date, 5) - # => ~D[2023-11-23] - Date.add(current_date, -2) - # => ~D[2023-11-16] - - Date.beginning_of_week(current_date) - # => ~D[2023-11-13] - Date.end_of_week(current_date) - # => ~D[2023-11-19] - - Date.leap_year?(current_date) - # => false - ``` - - Третий модуль называется `NaiveDateTime`, он уже поддерживает и дату и время, однако, этот модуль не поддерживает часовые пояса: - - ```elixir - current = NaiveDateTime.utc_now() - # => ~N[2023-11-18 15:08:23.108947] - - NaiveDateTime.add(current, 5, :second) - # => ~N[2023-11-18 15:08:28.108947] - NaiveDateTime.add(current, -30, :millisecond) - # => ~N[2023-11-18 15:08:23.078947] - NaiveDateTime.add(current, 5, :day) - # => ~N[2023-11-23 15:08:23.108947] - - NaiveDateTime.end_of_day(current) - # => ~N[2023-11-18 23:59:59.999999] - NaiveDateTime.beginning_of_day(current) - # => ~N[2023-11-18 00:00:00.000000] - ``` - - Четвертый модуль `DateTime` не имеет такого недостатка, как `NaiveDateTime`, то есть `DateTime` поддерживает часовые пояса, но за этим нужно следить. Многие функции из этого модуля требуют базу данных часовых поясов. По умолчанию они используют базу данных, которую возвращает функция `Calendar.get_time_zone_database`, а эта база поддерживает только пояс `“Etc/UTC”`. Если нужно менять часовые пояса, советую присмотреться к библиотеке [tzdata](https://github.com/lau/tzdata). Теперь изучим `DateTime`: - - ```elixir - current = DateTime.utc_now() - # => ~U[2023-11-18 15:16:12.046038Z] - future = DateTime.add(current, 2, :day) - # => ~U[2023-11-20 15:16:12.046038Z] - - DateTime.compare(current, future) # => :lt - DateTime.diff(current, future) # => -172800 - - DateTime.from_naive!(NaiveDateTime.utc_now(), "Etc/UTC") - # => ~U[2023-11-18 15:18:54.394424Z] - - DateTime.to_date(current) - # => ~D[2023-11-18] - ``` - - Как было видно из примеров, время и даты можно задавать через строковые метки (сигили), для `Time` - `~T`, для `Date` - `~D`, для `NaiveDateTime` - `~N`, для `DateTime` - `~U` соответственно: - - ```elixir - ~T[13:40:18.506292] - # => ~T[13:40:18.506292] - - ~D[2023-11-18] - # => ~D[2023-11-18] - ``` - -instructions: | - - Создайте функцию `shift_days`, которая принимает структуры `Time`, `DateTime`, `NaiveDateTime`, `Date` и смещает ее на количество переданных дней. Дни могут быть отрицательным числом: - - ```elixir - naive_time = NaiveDateTime.utc_now() - # => ~N[2023-11-17 18:24:21.345116] - - - Solution.shift_days(naive_time, -2) - # => ~N[2023-11-15 18:24:21.345116] - Solution.shift_days(naive_time, 1) - # => ~N[2023-11-18 18:24:21.345116] - Solution.shift_days(naive_time, 0) - # => ~N[2023-11-17 18:24:21.345116] - - date = Date.utc_today() - # => ~D[2023-11-17] - Solution.shift_days(date, -2) - # => ~D[2023-11-15] - Solution.shift_days(date, 1) - # => ~D[2023-11-18] - Solution.shift_days(date, 0) - # => ~D[2023-11-17] - ``` - -tips: - - | - [Официальная документация Date](https://hexdocs.pm/elixir/Date.html) - - | - [Официальная документация DateTime](https://hexdocs.pm/elixir/DateTime.html) - - | - [Официальная документация NaiveDateTime](https://hexdocs.pm/elixir/NaiveDateTime.html) - - | - [Официальная документация Time](https://hexdocs.pm/elixir/Time.html) - - | - [Про базу знаний о часовых поясах tzdata](https://habr.com/ru/articles/130401/) - - | - [Библиотека tzdata для Elixir](https://github.com/lau/tzdata) diff --git a/modules/65-extra/10-dates-and-times/en/data.yml b/modules/65-extra/10-dates-and-times/en/data.yml index 6a2e8fd..ff02eda 100644 --- a/modules/65-extra/10-dates-and-times/en/data.yml +++ b/modules/65-extra/10-dates-and-times/en/data.yml @@ -1,2 +1,3 @@ +--- name: Date and time tips: [] diff --git a/modules/65-extra/10-dates-and-times/ru/data.yml b/modules/65-extra/10-dates-and-times/ru/data.yml index 9c81675..1a2f5f3 100644 --- a/modules/65-extra/10-dates-and-times/ru/data.yml +++ b/modules/65-extra/10-dates-and-times/ru/data.yml @@ -1,3 +1,4 @@ +--- name: Даты и время tips: - |