На Хабре можно найти много публикаций, раскрывающих как теорию монад, так и практику их применения. Большинство этих статей ожидаемо про Haskell. Я не буду в n-й раз пересказывать теорию. Сегодня мы поговорим про некоторые проблемы Erlang, способы их решения с помощью монад, частичного применения функций и синтаксического сахара из erlando – классной библиотеки от команды RabbitMQ.

Введение

В Erlang есть иммутабельность, а монад нет*. Но благодаря наличию в языке функционала parse_transform и реализации erlando, возможность использования монад в Erlang все же есть.

Про иммутабельность в самом начале повествования, я заговорил не случайно. Иммутабельность почти везде и всегда – одна из основных идей Erlang. Иммутабельность и чистота функций позволяет концентрировать свое внимание на разработке конкретной функции и не бояться сайд эффектов. Но новичкам в Erlang, пришедшим, например, из Java или Python, довольно трудно понять и принять идеи Erlang. Особенно если вспомнить про синтаксис Erlang. Кто пытался начать использовать Erlang, наверняка отмечал его необычность и самостийность. Во всяком случае, у меня накопилось много отзывов новичков и “странный” синтаксис лидирует в рейтинге.

Erlando

Erlando – набор расширений Erlang, дающий нам:

• Частичное применение / каррирование функций с помощью Scheme-подобных cuts
• Haskell-подобные do-нотации
• import-as – синтаксический сахар для импорта функций из других модулей.

Замечание: Нижеприведенные примеры кода для иллюстрации фич erlando я взял из выступления Matthew Sackman’a, частично разбавив их своим кодом и объяснениями.

Абстракция Cut

Сразу к делу. Рассмотрим несколько функций из реального проекта:

info_all(VHostPath, Items) ->
map(VHostPath, fun (Q) -> info(Q, Items) end).

backing_queue_timeout(State = #q{ backing_queue = BQ }) ->
run_backing_queue(
BQ, fun (M, BQS) -> M:timeout(BQS) end, State).

reset_msg_expiry_fun(TTL) ->
fun (MsgProps) ->
MsgProps #message_properties{
expiry = calculate_msg_expiry(TTL)}
end.

Все эти функции созданы для подстановки параметров в простые выражения. На самом деле это частичное применение, так как некоторые параметры не будут известны до вызова. Вместе с гибкостью, эти функции привносят шум в наш код. Изменив немного синтаксис – введя cut – можно улучшить ситуацию.

Значение _

• _ может использоваться в шаблонах
• Cut позволяет использовать _ вне шаблонов
• Если находится вне шаблона, то становится параметром для выражения в котором он находится
• Множественное использование _ в рамках одного выражения приводит к подстановке нескольких параметров в это выражение
• Cut это не замена замыканий (funs)
• Аргументы вычисляются до cut функции

Cut использует _ в выражениях для указания, где должна быть применена абстракция. Cut оборачивает только ближайший уровень в выражении, но применение вложенных cut не запрещено.
Например list_to_binary([1, 2, math:pow(2, _)]). развернется в list_to_binary([1, 2, fun (X) -> math:pow(2, X) end]). но не в fun (X) -> list_to_binary([1, 2, math:pow(2, X)]) end..

Звучит слегка непонятно, давайте перепишем примеры выше с использованием cut:

info_all(VHostPath, Items) ->
     map(VHostPath, fun (Q) -> info(Q, Items) end).

info_all(VHostPath, Items) -> map(VHostPath, info(_, Items)).

backing_queue_timeout(State = #q{ backing_queue = BQ }) ->
    run_backing_queue(
     BQ, fun (M, BQS) -> M:timeout(BQS) end, State).

backing_queue_timeout(State = #q{backing_queue = BQ}) ->
    run_backing_queue(BQ, _:timeout(_), State).

reset_msg_expiry_fun(TTL) ->
    fun (MsgProps) ->
        MsgProps #message_properties {
        expiry = calculate_msg_expiry(TTL) }
    end.

reset_msg_expiry_fun(TTL) ->
    _ #message_properties { expiry = calculate_msg_expiry(TTL) }.

Порядок вычисления аргументов

Для иллюстрации порядка вычисления аргументов рассмотрим следующий пример:

f1(_, _) -> io:format("in f1~n").

test() ->
    F = f1(io:format("test line 1~n"), _),
    F(io:format("test line 2~n")).

Так как аргументы вычисляются до cut функции, на экран будет выведено:

test line 2
test line 1
in f1

Абстракция Cut в различных типах и шаблонах кода

• Tuples
  

  F = {_, 3},
  {a, 3} = F(a).

• Lists
  

  dbl_cons(List) -> [_, _ | List].
  test() ->
  F = dbl_cons([33]),
  [7, 8, 33] = F(7, 8).

• Records
  

  -record(vector, { x, y, z }).
  test() ->
  GetZ = _#vector.z,
  7 = GetZ(#vector { z = 7 }),
  SetX = _#vector{x = _},
  V = #vector{ x = 5, y = 4 } = SetX(#vector{ y = 4 }, 5).

• Cases
  

  F = case _ of
      N when is_integer(N) -> N + N;
      N -> N
  end,
  10 = F(5),
  ok = F(ok).

• Maps
  

  test() ->
  GetZ = maps:get(z, _),
  7    = GetZ(#{ z => 7 }),
  SetX = _#{x => _},
  V    = #{ x := 5, y := 4 } = SetX(#{ y => 4 }, 5).

• Сопоставление списков и конструирование бинарных данных
  

  test_cut_comprehensions() ->
  F = << <<(1 + (X*2))>> || _ <- _, X <- _ >>, %% Note, this'll only be a /2 !
  <<"AAA">> = F([a,b,c], [32]),
  F1 = [ {X, Y, Z} || X <- _, Y <- _, Z <- _,
                      math:pow(X,2) + math:pow(Y,2) == math:pow(Z,2) ],
  [{3,4,5}, {4,3,5}, {6,8,10}, {8,6,10}] =
      lists:usort(F1(lists:seq(1,10), lists:seq(1,10), lists:seq(1,10))).

Pros

• Кода стало меньше, следовательно его легче поддерживать.
• Код стал проще и опрятнее.
• Ушел шум от funs.
• Для новичков в Erlang удобнее писать Get/Set функции.

Cons

• Повышение порога входа для опытных Erlang разработчиков вместе с одновременным снижением порога входа для новичков. Теперь от команды требуется понимание cut и знание еще одного синтаксиса.

Do-нотация

Программная запятая – конструкция связывания вычислений. Erlang не имеет ленивой модели вычислений. Давайте представим, что было бы, если Erlang был бы ленив как Haskell

my_function() ->
    A = foo(),
    B = bar(A, dog),
    ok.

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

my_function() ->
    A = foo(),
    comma(),
    B = bar(A, dog),
    comma(),
    ok.

Продолжим преобразование:

my_function() ->
   comma(foo(),
         fun (A) -> comma(bar(A, dog),
                          fun (B) -> ok end)).

Исходя из вывода, comma/2 является идиоматической функцией >>=/2. Монада требует только три функции: >>=/2, return/1 и fail/1.
Все бы ничего, но синтаксис просто ужасен. Применим трансформеры синтаксиса из erlando.

do([Monad ||
      A <- foo(),
      B <- bar(A, dog),
      ok]).

Типы монад

Поскольку do-блок параметризован, мы можем использовать монады различного типа. Внутри do-блока вызовы return/1 и fail/1 разворачиваются в Monad:return/1 и Monad:fail/1 соответственно.

• Identity-monad.
  Тождественная монада – простейшая монада, не меняющая тип значений и не участвующая в управлении процессом вычислений. Применяется с трансформерами. Выполняет связывание выражений – программная запятая, рассмотренная выше.

  
  

• Maybe-monad.
  Монада вычислений с обработкой отсутствующих значений. Связывание параметра с параметризованным вычислением – это передача параметра вычислению, связывание отсутствующего параметра с параметризованным вычислением – отсутствующий результат.
  Рассмотрим пример применения maybe_m:

  
  

  if_safe_div_zero(X, Y, Fun) ->
  do([maybe_m ||
      Result <- case Y == 0 of
                    true  -> fail("Cannot divide by zero");
                    false -> return(X / Y)
                end,
      return(Fun(Result))]).

  
  

  Вычисление выражения прекращается, если возвращается nothing.

  
  

  {just, 6} = if_safe_div_zero(10, 5, _+4)  ## 10/5 = 2 -> 2+4 -> 6
  nothing = if_safe_div_zero(10, 0, _+4)

  
  

• Error-monad.
  Аналогично maybe_m, только с обработкой ошибок. Иногда принцип let it crash неприменим и ошибки нужно обработать в момент их возникновения. В этом случае в коде часто появляются лесенки из case, например такие:

  
  

  write_file(Path, Data, Modes) ->
  Modes1 = [binary, write | (Modes -- [binary, write])],
  case make_binary(Data) of
      Bin when is_binary(Bin) ->
          case file:open(Path, Modes1) of
              {ok, Hdl} ->
                  case file:write(Hdl, Bin) of
                      ok ->
                          case file:sync(Hdl) of
                              ok ->
                                  file:close(Hdl);
                              {error, _} = E ->
                                  file:close(Hdl),
                                  E
                          end;
                      {error, _} = E ->
                          file:close(Hdl),
                          E
                  end;
              {error, _} = E -> E
          end;
      {error, _} = E -> E
  end.

  
  

  make_binary(Bin) when is_binary(Bin) ->
  Bin;
  make_binary(List) ->
  try
      iolist_to_binary(List)
  catch error:Reason ->
          {error, Reason}
  end.

  
  

Читать такое неприятно, выглядит как лапша callback в JS. На помощь приходит error_m:

write_file(Path, Data, Modes) ->
    Modes1 = [binary, write | (Modes -- [binary, write])],
    do([error_m ||
        Bin <- make_binary(Data),
        Hdl <- file:open(Path, Modes1),
        Result <- return(do([error_m ||
                             file:write(Hdl, Bin),
                             file:sync(Hdl)])),
        file:close(Hdl),
        Result]).

make_binary(Bin) when is_binary(Bin) ->
    error_m:return(Bin);
make_binary(List) ->
    try
        error_m:return(iolist_to_binary(List))
    catch error:Reason ->
            error_m:fail(Reason)
    end.

• List-monad.
  Значения представляют собой списки, которые можно интерпретировать как несколько возможных результатов одного вычисления. Если одно вычисление зависит от другого, то второе вычисление производится для каждого результата первого, и полученные результаты (второго вычисления) собираются в список.
  Рассмотрим пример с классическими Пифагоровыми тройками. Вычислим их без монад:
  

  P = [{X, Y, Z} || Z <- lists:seq(1,20),
                    X <- lists:seq(1,Z),
                    Y <- lists:seq(X,Z),
                    math:pow(X,2) + math:pow(Y,2) == math:pow(Z,2)].

То же самое только с list_m:

P = do([list_m || Z <- lists:seq(1,20),
                  X <- lists:seq(1,Z),
                  Y <- lists:seq(X,Z),
                  monad_plus:guard(list_m, math:pow(X,2) + math:pow(Y,2) == math:pow(Z,2)),
                  return({X,Y,Z})]).

• State-monad.
  Монада вычислений с изменяемым состоянием.
  В самом начале статьи мы говорили про трудности новичков при работе с изменяемым состоянием. Часто код выглядит как-то так:
  

  State1 = init(Dimensions),
  State2 = plant_seeds(SeedCount, State1),
  {DidFlood, State3} = pour_on_water(WaterVolume, State2),
  State4 = apply_sunlight(Time, State3),
  {DidFlood2, State5} = pour_on_water(WaterVolume, State4),
  {Crop, State6} = harvest(State5),
  ...

С помощью трансформатора и cut-нотации этот код можно переписать в более компактном и читаемом виде:

StateT = state_t:new(identity_m),
SM = StateT:modify(_),
SMR = StateT:modify_and_return(_),
StateT:exec(
  do([StateT ||
      StateT:put(init(Dimensions)),
      SM(plant_seeds(SeedCount, _)),
      DidFlood <- SMR(pour_on_water(WaterVolume, _)),
      SM(apply_sunlight(Time, _)),
      DidFlood2 <- SMR(pour_on_water(WaterVolume, _)),
      Crop <- SMR(harvest(_)),
      ...
      ]), undefined).

• Omega-monad.
  Аналогична монаде list_m. Однако проход совершается диагонально.

Скрытая обработка ошибок

Наверное, одна из моих любимых фич монады error_m. Не важно, в каком месте произойдет ошибка, монада всегда вернет либо {ok, Result} либо {error, Reason}. Пример, иллюстрирующий поведение:

do([error_m ||
    Hdl <- file:open(Path, Modes),
    Data <- file:read(Hdl, BytesToRead),
    file:write(Hdl, DataToWrite),
    file:sync(Hdl),
    file:close(Hdl),
    file:rename(Path, Path2),
    file:delete(Path),
    return(Data)]).

Import_as

На закуску у нас синтаксический сахар import_as. Стандартный синтаксис атрибута -import/2 позволяет импортировать в локальный модуль функции из других. Однако этот синтаксис не позволяет присвоить альтернативное название импортированной функции. Import_as решает эту проблему:

-import_as({my_mod, [{size/1, m_size}]})
-import_as({my_other_mod, [{size/1, o_size}]})

Эти выражения разворачиваются в настоящие локальные функции соответственно:

m_size(A) -> my_mod:size(A).
o_size(A) -> my_other_mod:size(A).

Заключение

Конечно, монады позволяют контролировать процесс вычислений более выразительными методами, экономят код и время на его поддержку. С другой стороны, они привносят дополнительную сложность для неподготовленных членов команды.

* — на самом деле в Erlang монады существуют и без erlando. Запятая, разделяющая выражения – это конструкция линеаризации и связывания вычислений.

P.S. Недавно библиотека erlando была помечена авторами, как архивная. Данную статью я написал больше года назад. Тогда, впрочем, как и сейчас, на Хабре не было информации по монадам в Erlang. Чтобы исправить эту ситуацию, я публикую, хоть и с опозданием, данную статью.
Для использования erlando в erlang >= 22 необходимо исправить проблему с deprecated erlang:get_stacktrace/0. Пример фикса можно найти в моем форке: https://github.com/Vonmo/erlando/commit/52e23ecedd2b8c13707a11c7f0f14496b5a191c2

Спасибо за ваше время!