Haskell中Maybe的Alternative实现对应的C#惯用写法探讨

我在Haskell里可以用<|>操作符组合多个返回Maybe b的函数，依次尝试直到第一个返回非Nothing的结果，示例代码如下：

f :: a -> Maybe b
g :: a -> Maybe b
h :: a -> Maybe b

TryUntilSuccess :: a -> Maybe b
TryUntilSuccess x = f x <|> g x <|> h x

现在想知道在C#/面向对象编程里，对应的实现是不是用null结合if-else链？我知道使用null有一些需要考量的点，想确认这是不是惯用的替代方案。

你猜的没错，用null加if-else链确实是最直接的“入门级”实现方式，但它不是唯一的选择，而且随着C#版本的迭代，现在有更优雅、更安全的替代方案，我们来逐一拆解：

1. 传统if-else链（基于null） #

这是最直观的写法，和Haskell的逻辑一一对应：

public static B TryUntilSuccess<A, B>(A x, Func<A, B> f, Func<A, B> g, Func<A, B> h)
    where B : class // 限制引用类型，因为值类型不能为null
{
    var result = f(x);
    if (result != null) return result;
    
    result = g(x);
    if (result != null) return result;
    
    return h(x); // 如果都失败，返回null
}

但你提到的null的问题确实存在：

• 它无法区分“无结果”和“合法的null值”（比如某些场景下null本身就是有效返回）
• 容易引发NullReferenceException，尤其是在值类型场景下完全不适用

2. 使用Nullable<T>（值类型场景） #

如果你的返回类型是值类型，C#提供了Nullable<T>（简写为T?）来表示“存在或不存在”，避免直接用null的歧义：

public static int? TryUntilSuccess(int x, Func<int, int?> f, Func<int, int?> g, Func<int, int?> h)
{
    var result = f(x);
    if (result.HasValue) return result;
    
    result = g(x);
    if (result.HasValue) return result;
    
    return h(x);
}

这种方式比直接用null安全，但还是摆脱不了if-else的繁琐。

3. 用LINQ简化逻辑（更优雅的写法） #

你可以把所有待尝试的函数放到一个集合里，然后用FirstOrDefault找到第一个非null/非空的结果，代码会简洁很多：

// 值类型版本
public static B? TryUntilSuccess<A, B>(A x, params Func<A, B?>[] functions)
    where B : struct
{
    return functions.Select(func => func(x))
                    .FirstOrDefault(result => result.HasValue);
}

// 引用类型版本
public static B TryUntilSuccess<A, B>(A x, params Func<A, B>[] functions)
    where B : class
{
    return functions.Select(func => func(x))
                    .FirstOrDefault(result => result != null);
}

这种写法把重复的判断逻辑交给LINQ处理，代码更简洁，也更容易扩展（比如新增函数只需要加到参数里）。

4. 自定义Maybe<T>类型（类型安全的最佳实践） #

如果想完全避免null的问题，你可以自己实现一个类似HaskellMaybe的代数数据类型，或者使用成熟的第三方库（比如LanguageExt的Option<T>）。示例自定义Maybe<T>：

public abstract class Maybe<T>
{
    public abstract bool HasValue { get; }
    public abstract T Value { get; }
    
    public static Maybe<T> Some(T value) => new Some<T>(value);
    public static Maybe<T> None => new None<T>();
}

public class Some<T> : Maybe<T>
{
    public override bool HasValue => true;
    public override T Value { get; }
    
    public Some(T value) => Value = value;
}

public class None<T> : Maybe<T>
{
    public override bool HasValue => false;
    public override T Value => throw new InvalidOperationException("No value present");
}

然后实现类似<|>的操作符：

public static Maybe<T> operator <|>(Maybe<T> first, Maybe<T> second)
{
    return first.HasValue ? first : second;
}

这样你的“尝试直到成功”逻辑就和Haskell几乎一模一样了：

public static Maybe<B> TryUntilSuccess<A, B>(A x, Func<A, Maybe<B>> f, Func<A, Maybe<B>> g, Func<A, Maybe<B>> h)
{
    return f(x) <|> g(x) <|> h(x);
}

这种方式完全消除了null的歧义，类型安全，是函数式风格在C#里的最佳实践。

总结 #

• 如果你只是快速实现简单场景，null+if-else链是惯用的快速方案，但要注意null的风险
• 追求简洁和可扩展性的话，LINQ的FirstOrDefault是更好的选择
• 想要类型安全、避免null问题，自定义Maybe<T>或使用第三方函数式库是最优解

内容的提问来源于stack exchange，提问作者Matt R