В функциональной парадигме программирования побочные эффекты (side effects) представляют собой любое поведение, выходящее за рамки чистого вычисления — то есть изменение состояния или взаимодействие с внешним миром. Это может быть:

• вывод в консоль (IO.puts)

• чтение/запись в файл

• обращение к базе данных или веб-серверу

• генерация случайных чисел

• использование времени (например, :os.system_time)

• изменение глобальных переменных

В функциональных языках, включая Elixir, побочные эффекты допускаются, но жёстко изолируются от остальной логики. Это важно для сохранения основных преимуществ функционального программирования: предсказуемости, тестируемости и модульности кода.

Основные подходы к обработке побочных эффектов в Elixir

1. Изоляция эффектов во внешние функции

Elixir поощряет разделение функций на:

• чистые (pure) — возвращают значение, не взаимодействуют с внешним миром;

• нечистые — занимаются выводом, логированием, доступом к базе и т. д.

Пример:

defmodule Calculator do
def sum(a, b), do: a + b
end
defmodule Main do
def run do
result = Calculator.sum(5, 3)
IO.puts("Result: #{result}") # только здесь побочный эффект
end
end

2. Разделение слоёв логики

Обычно архитектура разбивается на три уровня:

• бизнес-логика (чистая)

• слой взаимодействия с внешним миром (нечистая часть)

• интерфейс пользователя (также нечистая часть)

Это позволяет локализовать и контролировать побочные эффекты, не распространяя их по всей системе.

3. Использование процессов для управления состоянием

В Elixir используется модель акторов (актеров), основанная на процессах Erlang VM (BEAM). Каждый процесс независим и имеет своё состояние.

Пример:

defmodule Counter do
def start do
spawn(fn -> loop(0) end)
end
defp loop(value) do
receive do
{:get, caller} ->
send(caller, {:value, value})
loop(value)
{:inc, n} ->
loop(value + n)
end
end
end

Здесь состояние (value) меняется, но остаётся локализовано внутри процесса, а внешний интерфейс взаимодействия с ним остаётся функциональным. Такой подход позволяет избежать глобального состояния и побочных эффектов вне контролируемого окружения.

4. Отложенное выполнение

Некоторые операции, такие как доступ к IO, могут быть «отложены» до финальной стадии выполнения, где их уже невозможно избежать.

Пример:

defmodule Reporter do
def prepare_output(data) do
"Report: #{Enum.join(data, ", ")}"
end
end
\# вывод на экран делается отдельно
output = Reporter.prepare_output(\["item1", "item2"\])
IO.puts(output)

5. Использование монад (в других языках)

Хотя в Elixir и Erlang нет монад как таковых (в отличие от Haskell), концепции управления эффектами (например, через Result, Maybe, Task, with) применяются. Они позволяют явно контролировать, что может пойти не так или что должно быть выполнено в определённом порядке.

Особенности работы с эффектами в Elixir

• Отсутствие глобального состояния. Переменные в Elixir иммутабельны, поэтому изменения не распространяются вне текущего контекста.

• Всё взаимодействие с внешним миром идёт через процессы. Это могут быть GenServer, Task, Agent, которые инкапсулируют состояние и работают по сообщениям.

• Обработка ошибок встроена в модель акторов. Принцип «let it crash» позволяет нечистым процессам завершаться при ошибке, а их поведение восстанавливается супервизором.

Типовые нечистые операции в Elixir

Все эти действия нужно выносить в контролируемые зоны, не внедряя их в чистую бизнес-логику.

Практика: работа с побочными эффектами в Pipeline

def process(data) do
data
|> Enum.map(&String.upcase/1)
|> Enum.join(", ")
|> IO.puts()
end

Здесь map и join — чистые операции, а IO.puts — нечистая. Благодаря |> видно, где заканчивается чистота, что делает эффект очевидным и локализованным.

Проверка чистоты функции

Если функция:

• зависит только от аргументов,

• не читает и не пишет внешние данные,

• не вызывает IO, File, DateTime, Random и т. д.,

то она чистая. Всё остальное — побочные эффекты, которые должны быть отделены от остальной логики.