5

我正在使用option<`a`>Petricek 书（真实世界函数式编程）中 F# monad 的 C# 实现：

internal enum OptionType { Some, None }

internal abstract class Option<T>
{
    private readonly OptionType tag;

    protected Option(OptionType tag)
    {
        this.tag = tag;
    }

    public OptionType Tag
    {
        get { return this.tag; }
    }

    public bool MatchNone()
    {
        return this.Tag == OptionType.None;
    }

    public bool MatchSome(out T value)
    {
        if (this.Tag == OptionType.Some)
        {
            value = ((Some<T>)this).Value;
        }
        else
        {
            value = default(T);
        }
        return this.Tag == OptionType.Some;
    }
}

internal sealed class None<T> : Option<T>
{
    public None() : base(OptionType.None) { }
}

internal sealed class Some<T> : Option<T>
{
    private readonly T value;

    public Some(T value)
        : base(OptionType.Some)
    {
        this.value = value;
    }

    public T Value
    {
        get
        {
            return this.value;
        }
    }
}

internal static class Option
{
    public static Option<T> None<T>()
    {
        return new None<T>();
    }

    public static Some<T> Some<T>(T value)
    {
        return new Some<T>(value);
    }
}

internal static class OptionExtensions
{
    public static Option<T2> Bind<T1, T2>(this Option<T1> option, Func<T1, Option<T2>> func)
    {
        T1 value1;
        if (option.MatchSome(out value1))
        {
            return func(value1);
        }
        return Option.None<T2>();
    }

    public static Option<T2> Map<T1, T2>(this Option<T1> option, Func<T1, T2> func)
    {
        T1 value1;
        if (option.MatchSome(out value1))
        {
            return Option.Some(func(value1));
        }
        return Option.None<T2>();
    }
}

现在我需要一个操作来提取值（如果不是None或返回默认值）。

我想知道这是否可以使用 and 的组合Map，Bind但我认为不是。

所以我回到F# 文档，它给了我一些其他有用的扩展方法的提示，但不完全是我需要的。

我设计了这个功能来满足我的需要：

public static T2 Return<T1, T2>(this Option<T1> option, Func<T1, T2> func, T2 noneValue)
{
    T1 value1;
    if (option.MatchSome(out value1))
    {
        return func(value1);
    }
    return noneValue;
}

因此，为了不重新发明轮子，问题是：是否有参考或通用功能模式来定义Option<T>monad 上的操作？根据需要添加新操作是否正确？

4

1 回答 1

16

您始终可以提取值的 monad 通常是comonad。你知道 monadM<T>有方法（在 C# 语法中）

static M<T> Unit<T>(T t) { ... }
static M<R> Bind<A, R>(M<A> ma, Func<A, M<R>> func) { ... }

或者，或者，你可以用

static M<T> Unit<T>(T t) { ... }
static M<R> FMap<A, R>(M<A> ma, Func<A, R> func) { ... }
static M<T> Join<T>(M<M<T>> mmt) { ... }

这两种表征是等价的；您可以构建另一个的给定实现。

一个comonad有操作

static T Extract<T>(M<T> mt) { ... } 
static M<R> Extend<A, R>(M<A> ma, Func<M<A>, R> func) { ... }

Extract 是 Unit 的“对立面”，Extend 是 Bind 的“对立面”。

或者，您也可以使用以下操作定义一个comonad：

static T Extract<T>(M<T> mt) { ... } 
static M<R> FMap<A, R>(M<A> ma, Func<A, R> func) { ... }
static M<M<T>> Duplicate<T>(M<T> mt) { ... }

其中 Duplicate 是 Join 的“对立面”。同样，这两种表征是等价的；给定一个，您可以构建另一个。

显然，您不能仅在给定 Bind、Unit、FMap 和 Join 的情况下实现 Extract，因为它们都不会以任何方式返回 T，并且它是您需要的 T。

对于任何一个版本的 comonad，您遇到的问题是可选的 monad 真的不是 comonad，因为如果 monadic 值“缺失”，则没有自然的方法来实现 Extract。

现在，你可以做Nullable<T>你想做的事。Nullable<T>.GetValueOrDefault()如果有则返回值，如果没有则返回default(T)。如果你想把 Optional 变成一个comonad，这可能是你可以在这里做的最好的事情。

于 2013-04-11T19:11:04.507 回答