Optionals 的功能组成

Question

我有 2 个要组合的 Optionals（或 Maybe 对象），以便得到以下结果：

                ||       first operand 
    second      ++-------------+-------------
    operand     ||    empty    | optional(x)
    ============||=============|=============
    empty       ||    empty    | optional(x)
    ------------++-------------+-------------
    optional(y) || optional(y) |optional(x+y)

换句话说，一个非空的 Optional 总是替换/覆盖一个空的 Optional，并且两个非空的 Optional 根据某个+函数组合在一起。

最初，我认为标准的单子flatMap方法可以解决问题，但是（至少在 Java 中）当原始 Optional 已经为空时， Optional.flatMap总是返回一个空的可选项（我不确定是否有任何其他实现会遵守与单子定律）。

然后，由于两个操作数都包装在同一个单子类型中，我认为这对于 Applicative Functor 来说可能是一项不错的工作。 我尝试了几个不同的功能库，但我无法使用我尝试的任何zip / ap方法实现所需的行为。

在我看来，我正在尝试做的似乎是一个相当常见的操作，可以用 Optionals 来做，而且我意识到我可以用所需的行为编写自己的操作符。 不过，我想知道函数式编程中是否有标准的函数/方法来实现这种常见的操作？

更新：我删除了java标签，因为我很好奇其他语言如何处理这种情况

Answer 1

在函数式语言中，您可以使用模式匹配来执行此操作，例如 (Haskell)：

combine :: Maybe t -> Maybe t -> (t -> t -> t) -> Maybe t
combine (Some x) (Some y) f = Some (f x y)
combine (Some x) _ _ = (Some x)
combine _ (Some y) _ = (Some y)
combine None None _ = None

还有其他方法可以编写它，但是您基本上是在案例上进行模式匹配。 请注意，这仍然涉及“解包”选项，但由于它内置于语言中，因此不太明显。

Answer 2

如果不“解包”它们，就不可能组合可选对象。

我不知道你案子的具体情况。 对我来说，仅仅为了融合这两个选项而创建这样的逻辑是一种矫枉过正的做法。

但是，尽管如此，流还是有一个可能的解决方案。

我假设您不会将可选对象作为参数传递（因为不鼓励这种做法）。 因此，有两个虚拟方法返回Optional<T> 。

方法combine()需要一个BinaryOperator<T>作为参数，并通过连接由getX()和getY()返回的每个可选对象产生的单例流来创建一个流。

reduce(BinaryOperator)的风格将产生一个可选的结果。

public static <T> Optional<T> getX(Class<T> t) {
    return // something
}

public static <T> Optional<T> getY(Class<T> t) {
    return // something
}

public static <T> Optional<T> combine(BinaryOperator<T> combiner, 
                                      Class<T> t) {
    
    return Stream.concat(getX(t).stream(), getY(t).stream())
        .reduce(combiner);
}

如果我们将问题概括为“如何组合N个可选对象” ，则可以这样解决：

@SafeVarargs
public static <T> Optional<T> combine(BinaryOperator<T> combiner,
                                      Supplier<Optional<T>>... suppliers) {
    
    return Arrays.stream(suppliers)
        .map(Supplier::get)           // fetching Optional<T>
        .filter(Optional::isPresent)  // filtering optionals that contain results to avoid NoSuchElementException while invoking `get()`
        .map(Optional::get)           // "unpacking" optionals
        .reduce(combiner);
}

Answer 3

在 Haskell 中，您可以通过将任何半群包装在 Maybe 中来做到这一点。 具体来说，如果您想将数字相加：

Prelude> import Data.Semigroup
Prelude Data.Semigroup> Just (Sum 1) <> Just (Sum 2)
Just (Sum {getSum = 3})
Prelude Data.Semigroup> Nothing <> Just (Sum 2)
Just (Sum {getSum = 2})
Prelude Data.Semigroup> Just (Sum 1) <> Nothing
Just (Sum {getSum = 1})
Prelude Data.Semigroup> Nothing <> Nothing
Nothing

上面链接的文章包含更多解释，以及一些 C# 示例。

Answer 4

这是一种方法：

a.map(x -> b.map(y -> x + y).orElse(x)).or(() -> b)

Ideone 演示

Answer 5

OptionalInt x = ...
OptionalInt y = ...

OptionalInt sum = IntStream.concat(x.stream(), y.stream())
    .reduce(OptionalInt.empty(),
        (opt, z) -> OptionalInt.of(z + opt.orElse(0)));

从 java 9 开始，您可以将 Optional 转换为 Stream。 使用 concat 您可以获得 0、1 或 2 个元素的 Stream。

当元素为 0 时将其减少为empty ，更多则将其添加到之前的 OptionalInt 中，默认为 0。

由于需要empty() ，因此不是很直接（ .sum() ）。

Answer 6

您可以通过结合flatMap和map在 Java 中实现您的功能：

optA.flatMap(a -> optB.map(b -> a + b));

更一般的例子：

public static void main(String[] args) {
    test(Optional.empty(), Optional.empty());
    test(Optional.of(3), Optional.empty());
    test(Optional.empty(), Optional.of(4));
    test(Optional.of(3), Optional.of(4));
}

static void test(Optional<Integer> optX, Optional<Integer> optY) {
    final Optional<Integer> optSum = apply(Integer::sum, optX, optY);
    System.out.println(optX + " + " + optY + " = " + optSum);
}

static <A, B, C> Optional<C> apply(BiFunction<A, B, C> fAB, Optional<A> optA, Optional<B> optB) {
    return optA.flatMap(a -> optB.map(b -> fAB.apply(a, b)));
}

由于 flatMap 和 map 是 Optional/Maybe 的标准函数（以及一般的 monad 类型），这种方法应该适用于任何其他语言（尽管大多数 FP 语言会有更简洁的解决方案）。 例如在 Haskell 中：

combine ma mb = do a <- ma ; b <- mb ;  return (a + b)

Answer 7

在 F# 中，我将此逻辑称为reduce 。

原因：

• 该函数必须是'a -> 'a -> 'a类型，因为它只能结合相等类型的思想。

• 像其他reduce操作一样，比如 on list，你总是需要至少一个值，否则它会失败。

使用一个option和其中两个选项，您只需要涵盖四个案例。 在 F# 中，它将以这种方式编写。

(* Signature: ('a -> 'a -> 'a) -> option<'a> -> option<'a> -> option<'a> *)
let reduce fn x y =
    match x,y with
    | Some x, Some y -> Some (fn x y)
    | Some x, None   -> Some x
    | None  , Some y -> Some y
    | None  , None   -> None

printfn "%A" (reduce (+) (Some 3) (Some 7)) // Some 10
printfn "%A" (reduce (+) (None)   (Some 7)) // Some 7
printfn "%A" (reduce (+) (Some 3) (None))   // Some 3
printfn "%A" (reduce (+) (None)   (None))   // None

在另一个让我们说类似伪 C# 语言的情况下，它看起来像。

Option<A> Reduce(Action<A,A,A> fn, Option<A> x, Option<A> y) {
    if ( x.isSome ) {
        if ( y.isSome ) {
            return Option.Some(fn(x.Value, y.Value));
        }
        else {
            return x;
        }
    }
    else {
        if ( y.isSome ) {
            return y;
        }
        else {
            return Option.None;
        }
    }
}