Точное техническое определение : Монада в Ruby будет любым классом с методами bind и self.unit, определенными так, чтобы для всех экземпляров m:
m.class.unit[a].bind[f] == f[a]
m.bind[m.class.unit] == m
m.bind[f].bind[g] == m.bind[lambda {|x| f[x].bind[g]}]
Некоторые практические примеры
Очень простой пример монады - это ленивая монада Identity, которая эмулирует ленивую семантику в Ruby (строгом языке):
class Id
def initialize(lam)
@v = lam
end
def force
@v[]
end
def self.unit
lambda {|x| Id.new(lambda { x })}
end
def bind
x = self
lambda {|f| Id.new(lambda { f[x.force] })}
end
end
Используя это, вы можете ленивым образом соединять вместе цепочки. Например, в следующем примере x является контейнером, «содержащим» 40, но вычисление не выполняется до второй строки, о чем свидетельствует тот факт, что оператор puts ничего не выводит до force называется:
x = Id.new(lambda {20}).bind[lambda {|x| puts x; Id.unit[x * 2]}]
x.force
Несколько похожим, менее абстрактным примером была бы монада для получения значений из базы данных. Давайте предположим, что у нас есть класс Query с методом run(c), который принимает соединение с базой данных c, и конструктор из Query объектов, который принимает, скажем, строку SQL. Так что DatabaseValue представляет значение, поступающее из базы данных. DatabaseValue является монадой:
class DatabaseValue
def initialize(lam)
@cont = lam
end
def self.fromQuery(q)
DatabaseValue.new(lambda {|c| q.run(c) })
end
def run(c)
@cont[c]
end
def self.unit
lambda {|x| DatabaseValue.new(lambda {|c| x })}
end
def bind
x = self
lambda {|f| DatabaseValue.new(lambda {|c| f[x.run(c)].run(c) })}
end
end
Это позволит вам объединять вызовы базы данных через одно соединение, например:
q = unit["John"].bind[lambda {|n|
fromQuery(Query.new("select dep_id from emp where name = #{n}")).
bind[lambda {|id|
fromQuery(Query.new("select name from dep where id = #{id}"))}].
bind[lambda { |name| unit[doSomethingWithDeptName(name)] }]
begin
c = openDbConnection
someResult = q.run(c)
rescue
puts "Error #{$!}"
ensure
c.close
end
Хорошо, так с какой стати ты это сделал? Потому что есть чрезвычайно полезные функции, которые можно написать один раз для всех монад . Так что код, который вы обычно пишете снова и снова, можно повторно использовать для любой монады, если вы просто реализуете unit и bind. Например, мы можем определить миксин Monad, который наделяет все такие классы некоторыми полезными методами:
module Monad
I = lambda {|x| x }
# Structure-preserving transform that applies the given function
# across the monad environment.
def map
lambda {|f| bind[lambda {|x| self.class.unit[f[x]] }]}
end
# Joins a monad environment containing another into one environment.
def flatten
bind[I]
end
# Applies a function internally in the monad.
def ap
lambda {|x| liftM2[I,x] }
end
# Binds a binary function across two environments.
def liftM2
lambda {|f, m|
bind[lambda {|x1|
m.bind[lambda {|x2|
self.class.unit[f[x1,x2]]
}]
}]
}
end
end
А это, в свою очередь, позволяет нам делать еще больше полезных вещей, например определять эту функцию:
# An internal array iterator [m a] => m [a]
def sequence(m)
snoc = lambda {|xs, x| xs + [x]}
lambda {|ms| ms.inject(m.unit[[]], &(lambda {|x, xs| x.liftM2[snoc, xs] }))}
end
Метод sequence принимает класс, который смешивается в Monad, и возвращает функцию, которая принимает массив монадических значений и превращает его в монадическое значение, содержащее массив. Это могут быть значения Id (превращение массива идентификаторов в идентификатор, содержащий массив) или объекты DatabaseValue (превращение массива запросов в запрос, возвращающий массив) или функции (превращение массива функций в функция, которая возвращает массив), или массивы (переворачивание массива массивов наизнанку), или парсеры, продолжения, конечные автоматы или что-либо еще, что может смешиваться в модуле Monad (который, как оказалось, верно почти для всех структур данных).