Ведение журнала из парадигмы функционального программирования

Давайте посмотрим на монадическое решение Haskell. Идея ведения журнала заключается в том, что в наших вычислениях есть дополнительный метод, который записывает сообщение где-то «вне». Есть много способов представить такие вычисления, но один из самых общих - создать монаду:

class (Monad m) => MonadWriter w m | m -> w where
    tell   :: w -> m ()

Тип w представляет сообщения, а функция tell - это то, что «отправляет» сообщение в монадическое (полное) вычисление.

Примечания:

• MonadWriter Haskell на самом деле богаче, он содержит функции, позволяющие проверять и изменять w, но давайте пока оставим это в стороне.
• Часть | m -> w на самом деле не важна для объяснения, она просто означает, что w исправлено для данного m.

Чаще всего используется реализация Writer, которая представляет собой просто пару. Один его элемент - результат вычислений, а другой - последовательность письменных сообщений. (На самом деле это не совсем последовательность, это более общий моноид, который определяет операции для объединения нескольких сообщений в одно.) Вы можете изучить решение Haskell, посмотрев на Модуль Writer. Однако он написан в более общем плане с использованием WriterT преобразователя монад, поэтому, если вы не фанат монад, его будет довольно трудно прочитать. То же самое можно сделать и на других функциональных языках, например см. этот пример на Scala.

Но есть и другие возможные, более ориентированные на побочные эффекты (все еще функциональные) реализации вышеуказанного класса типов. Мы можем определить tell для отправки сообщений какому-либо внешнему приемнику, например, в стандартный вывод, в файл и т. Д. Например:

{-# LANGUAGE FunctionalDependencies, TypeSynonymInstances, FlexibleInstances #-}

instance MonadWriter String IO where
    tell = putStrLn

Здесь мы говорим, что IO можно использовать как средство ведения журнала, которое записывает Strings в стандартный вывод. (Это просто упрощенный пример, полная реализация, вероятно, будет иметь преобразователь монад, который добавит tell функциональность к любой монаде, основанной на IO.)

Я новичок в функциональном программировании, но вот попытка на Scala:

object FunctionalLogging {

  type Result = Int

  class ResultWithLogging(val log: List[String], val result: Result) {}

  def functionWithLogging(log: List[String], arg: String): ResultWithLogging = {
    def function(arg: String): Result = arg.length

    new ResultWithLogging(log :+ ("Calling function(" + arg +")"), function(arg))
  }

  val result = functionWithLogging(List(), "Hello world!")

  // -- Pure functional code ends here --
  println("Result = " + result.result)
  println("Log = " + result.log)
}

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

Мне кажется, что ведение журнала является желательным побочным эффектом по определению, поэтому, если вы согласитесь с моим определением, вопрос в том, как изолировать нефункциональное от функционального кода. На практике я, вероятно, начал бы с объекта Scala (возможно, слишком похожего на синглтон - черта, вероятно, лучше Scala) или актора, который накапливает сообщения журнала и делает с ними все, что нужно.

Это более прагматичный взгляд: Вход в Scala

Изменить

В этом вопросе говорится о монадах Haskell и вводе-выводе: Какие еще способы обработки состояний можно использовать на чистом функциональном языке, кроме Monads?