Монады в Erlang

На Хабре можно найти много публикаций, раскрывающих как теорию монад, так и практику их применения. Большинство этих статей ожидаемо про 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

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