Монада Maybe на стероидах
Про монады на Хабре было ужестолько много публикаций, что, мне кажется, не хватает еще одной.
Я не буду расписывать, что такое монада, я просто покажу одну забавную реализацию монады Maybe (мы же в хабе «Ненормальное программирование»?).
Давайте объявим вот такой простой делегат:
public delegate T IMaybe<out T>();
Сейчас я покажу, что такого простого определения будет достаточно, чтобы создать полноценный опциональный тип (Optional type).
Монада должна иметь два метода — Return и Bind. Первый «заворачивает» немонадическое значение в монаду, второй — позволяет связывать два монадических вычисления.
Для удобства создадим статический класс и все нужные функции сделаем функциями-расширениями (extension methods) от нашего типа и все методы будем складывать в него:
public static class Maybe
{
}
Первая функция — Return — достаточно простая. Из значения мы должны сделать делегат, который его возвращает:
public static IMaybe<T> Return<T>(T x)
{
return () => x;
}
У Maybe также должно быть объявлено нечто, отвечающие за отсутствие значения. В нашем случае это будет делегат, который бросает исключение:
public static IMaybe<T> Nothing<T>()
{
return () => { throw new InvalidOperationException("Нельзя получить значение"); };
}
Второй метод у монады — Bind — должен связывать два вычисления. Его сигнатура:
public static IMaybe<TResult> Bind<TArg, TResult>(this IMaybe<TArg> maybe, Func<TArg, IMaybe<TResult>> func)
Давайте с ним разберемся поближе.
Первый аргумент — собственно, первое монадическое значение. Второй аргумент — функция, которая из значения внутри монады создает новое монадическое значение. Реализация метода Bind должна уметь получать значение из монады. В нашем случае, чтобы получить значение, достаточно просто вызвать наш делегат.
public static IMaybe<TResult> Bind<TArg, TResult>(this IMaybe<TArg> maybe, Func<TArg, IMaybe<TResult>> func)
{
return () => {
var value = maybe();
var newMaybe = func(value);
return newMaybe();
};
}
Здесь есть некоторая хитрость. Метод Bind вполне мог иметь и такую реализацию:
public static IMaybe<TResult> Bind<TArg, TResult>(this IMaybe<TArg> maybe, Func<TArg, IMaybe<TResult>> func)
{
// неправильная реализация!
return func(maybe());
}
Однако тут есть подвох. Если первым аргументом мы передаем Nothing, то метод Bind выбросит исключение сразу после вызова. Но мы-то хотим, чтобы Bind связывал два вычисления, а не производил их. Поэтому Bind должен отложить получение результата из первой монады и собственно вычисление над значением из монады до тех пор, пока значение не понадобится потребителю нашей Maybe.
Добавим еще несколько методов для нашего Maybe: Select, Where, SelectMany
Метод Select производит некоторую трансформацию над объектом внутри Maybe. Он может быть реализован с помощью Bind и Return:
public static IMaybe<TResult> Select<TArg, TResult>(this IMaybe<TArg> maybe, Func<TArg, TResult> func)
{
return maybe.Bind(value => Return(func(value)));
}
Where фильтрует значение внутри Maybe и возвращает Nothing, если значение не удовлетворяет предикату:
public static IMaybe<T> Where<T>(this IMaybe<T> maybe, Func<T, bool> predicate)
{
return maybe.Bind(x => predicate(x) ? Return(x) : Nothing<T>());
}
SelectMany — это аналог Bind, который позволит писать нам выражения, используя Linq синтаксис. От простого Bind отличается наличием финальной проекции от значений обоих монад:
public static IMaybe<TC> SelectMany<TA, TB, TC>(this IMaybe<TA> ma, Func<TA, IMaybe<TB>> maybeSelector, Func<TA, TB, TC> resultSelector)
{
return ma.Bind(a => maybeSelector(a).Select(b => resultSelector(a, b)));
}
Примечательно, что для методы Select, Where и SelectMany ничего не знают о внутреннем устройстве нашего Maybe — они используют только Bind, Return и пустое значение (Nothing для Maybe). Мы могли бы подставить другую реализацию Maybe — и эти методы остались бы неизменны. Более того, мы могли бы подставить другую монаду, например List:
public static IEnumerable<T> Return<T>(T x)
{
return new[] { x };
}
public static IEnumerable<T> Nothing<T>()
{
yield break;
}
public static IEnumerable<TResult> Bind<TArg, TResult>(this IEnumerable<TArg> m, Func<TArg, IEnumerable<TResult>> func)
{
foreach (var arg in m)
{
foreach (var result in func(arg))
{
yield return result;
}
}
}
… и снова эти методы остались бы такими же. Если бы у нас были тайп-классы (type class), мы бы объявили эти методы над тайп-классом Monad (как это делается* в Хаскелле) (*на самом деле нет).
Последнее, что осталось — это, собственно, использование нашего Maybe:
var one = Maybe.Return(1);
var nothing = Maybe.Nothing<int>();
var nothing2 =
from ax in one
from ay in nothing
select ax + ay;
var two = one.Where(z => z > 0).Select(z => z + 1);
Console.WriteLine(one());
Console.WriteLine(two());
Console.WriteLine(nothing2());
У нас нет другого способа получить значение из монады, кроме как вызвать делегат, что и происходит в последних трех строчках. Последняя строчка ожидаемо падает с исключением «Нельзя получить значение».
Все вместе можно увидеть здесь.
