Option<T> 集合的功能转换

Question

我有一个Option<T> 实例的集合，并希望从IEnumerable<Option<T>> 转换为Option<IEnumerable<T>>

如果 ALL 选项有一个值，那么我想要一个带有收集值的 Some<IEnumerable<T>>，如果集合中的 ANY 项目是 None，那么我想要一个None<IEnumerable<T>>

这似乎是一个很常见的函数转换，但我不确定它是否存在于主流函数库中，或者它会被称为什么。似乎类似于FlatMap，但不完全是，因为我不想只过滤掉None 值。

我可以自己实现它，但想知道它是否已经作为函数构造存在。不要介意什么语言，C#、Scala、Haskell 等。

Answer 1

Language-ext 作者在这里，你只需要调用.Sequence() 来反转内部和外部 monad：

IEnumerable<Option<int>> items = ...;

Option<IEnumerable<int>> result = items.Sequence();

如果序列中的任何项目是None，则返回None，否则返回Some，它具有您正在寻找的确切行为。

您还可以使用.Traverse(...) 随时​​映射结果。

Answer 2

我玩了一下，似乎 f# fold 和 foldBack 在这种情况下可能有用。以下是一些示例：

let l1 = [Some 1; Some 2; None]
let l2 = [Some 3; Some 4; Some 5]


let acc (ac: int list option) le = 
    match ac, le with
    | Some ac, Some le -> Some (le::ac)
    | _, _ -> None

//this will reverse the order of elements if all present
let r1 = l1 |> List.fold acc (Some [])
let r2 = l2 |> List.fold acc (Some [])

//the order of elements preserved
let acc2 le (ac: int list option) = acc ac le
let r3 = List.foldBack acc2 l1 (Some [])
let r4 = List.foldBack acc2 l2 (Some [])

//or...
let r3b = l1 |> List.foldBack acc2 <| (Some [])
let r4b = l2 |> List.foldBack acc2 <| (Some [])

Answer 3

您可以推出自己的扩展方法，该方法依赖于 System.Linq 命名空间中的可用原语：

public static Option<IEnumerable<T>> AllSome<T>(this IEnumerable<Option<T>> input)
            where T : class
            => (input.All(o => o.IsSome)) ?
                new Some<IEnumerable<T>>(input.Select(o => (o as Some<T>).Value)) :
                new None<IEnumerable<T>>() as Option<IEnumerable<T>>;

这是基于我为支持此示例而编写的 Option 类型的一次性实现，请随意调整以适应您的 Option：

public class Option<T>
    where T: class
{
    protected T value;
    public bool IsSome => value != default(T);
}

public class Some<T> : Option<T>
    where T: class
{
    public Some(T value) => base.value = value;
    public T Value => base.value;
}

public class None<T> : Option<T>
    where T: class
{

}

Answer 4

函数式编程概念的“语言家族”不止一个。

在 Haskell（显然还有 Scala）中，这称为sequence，是称为Traversable 的抽象或类型类的一部分； sequence 是一种特殊的遍历。

存在其他语言家族，最著名的是 ML。这就是术语Option 的来源（在Haskell 中称为Maybe）。虽然我精通 F#（这是一种 ML 方言），但我不知道 traverse/sequence 在那里有一个既定的术语。

Answer 5

正如你所说，你不介意这种语言，我在这里有一个使用 F# 的示例，它具有开箱即用的 Option<T>：

let chooseAll source =
    let anyNone = source |> Seq.exists Option.isNone
    if anyNone then None else Some source

let s = [Some 1; Some 2; None]
let result1 = s |> chooseAll // None
let s = [Some 4; Some 5]
let result2 = s |> chooseAll // Some {4;5}

如果您不熟悉 F#，Seq 是 IEnumerable<T> 的类型别名。这里chooseAll 有签名seq<'a option> -> seq<'a> option，转换为C# 友好的语法是IEnumerable<Option<T>> -> Option<IEnumerable<T>>。

Answer 6

这些语言结构不是最初在 C# 中呈现的；但是，有多个函数式编程库可用于此类目的。我的选择是 Paul Louth 的language-ext；迄今为止我为 C# 找到的最丰富的 FP 库。