Scala的部分函数是否具有Java等价物？

Question

Scala具有部分函数,这些函数仅适用于输入类型的某些值,但不是全部:

val isEven: PartialFunction[Int, String] = {
  case x if x % 2 == 0 => x+" is even"
} 

assert(isEven(10) equalsIgnoreCase "10 is even")
assert(isEven.isDefinedAt(11) == false)

而且,更有用的是,scala允许将"partialness"应用于a的子类型trait:

sealed trait BaseTrait

case class Foo(i : Int) extends BaseTrait
case class Bar(s : String) extends BaseTrait

val fooPartialFunc : PartialFunction[BaseTrait, Int] = {
  case f : Foo => 42 + f.i
}

assert(fooPartialFunc(Foo(8)) == 50)
assert(fooPartialFunc.isDefinedAt(Bar("hello")) == false)

java 8中的等价物是什么？

大多数谷歌搜索结果混淆了"部分功能"与currying,例如"部分应用功能".

Answer 1

Java 8惯用语,但不是完全忠实的方法

Java 8中最典型的东西是Optional类:

import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;

import org.junit.Test;

import java.util.Optional;

public class OptionalAsPartialFunction {

  Optional<String> isEven(final int x) {
    return Optional.of(x)
        .filter(i -> i % 2 == 0)
        .map(i -> i + " is even");
  }

  @Test
  public void example() {
    assertThat(isEven(10).get(), equalTo("10 is even"));
    assertThat(isEven(11).isPresent(), is(false));
  }
}

如果您熟悉Optional,那么您将看到i + " is even"仅在过滤条件i % 2 == 0为true 时才评估字符串并置.如果你不熟悉Java的Optional,你可以用以下内容写出来if/else:

Optional<String> isEven(final int x) {
  if (x % 2 == 0) {
    return Optional.of(x + " is even");
  } else {
    return Optional.empty();
  }
}

这应该完全清楚,当且仅当保护条件的计算结果为true时,才会计算字符串连接.

一种更忠实但更少习惯(Java)的方法

使用朴素的方法,你正在调用函数,并获得一个Optional,它包含函数的实际值,或者不包含函数的实际值.但是Scala的PartialFunction有点复杂.从您链接到的文档:

即使isDefinedAt对a:A返回true,调用apply(a)仍可能抛出异常,因此以下代码是合法的:

val f: PartialFunction[Int, Any] = { case _ => 1/0 }

因此,我们希望能够检查输入是否"已定义"函数,即使尝试计算该输入是否实际上是错误.

因此,更忠实的方法是使用Optional<Supplier<...>>.外部Optional让你知道是否有要执行的计算,内部Supplier允许你执行该计算(如果你选择).所以这个例子将成为:

  Optional<Supplier<String>> isEven(final int x) {
    return Optional.of(x)
        .filter(i -> i % 2 == 0)
        .map(i -> () -> i + " is even");
  }

或者,用if/else:

Optional<Supplier<String>> isEven(final int x) {
  if (x % 2 == 0) {
    return Optional.of(() -> x + " is even");
  } else {
    return Optional.empty();
  }
}

并且isPresent()仍然检查函数是否已定义,但get()现在将返回Supplier其get()方法将实际计算该值的函数:

  @Test
  public void example() {
    assertThat("isPresent() checks whether the function is defined for the input", //
        isEven(10).isPresent(), equalTo(true));
    assertThat("get() returns the supplier that actually computes the value", //
        isEven(10).get().get(), equalTo("10 is even"));
    assertThat("isPresent() checks whether the function is defined for the input", //
        isEven(11).isPresent(), is(false));
  }

Answer 2

Java似乎并没有PartialFunction直接提供，但是它提供了一些可用于定义自己的接口PartialFunction<X,Y>。A PartialFunction<X, Y>本质上就是：

• 一个Predicate<X>用于测试类型的值是否X是在域中
• Function<X, Y>对被调用的实际函数定义如果该函数的参数值来定义。

在下面，我草绘了如何利用Predicate和Function实现PartialFunction。在此草图中，我仅定义了三个最重要的方法：

• isDefinedAt本质上是Predicates test。
• apply调用test，如果成功，则调用applyIfDefined，它表示“函数的实际主体”（caseScala 中s的右侧）
• orElse 证明了与普通功能组成不同的组成结构，只是概念的证明

这是完整的Java代码：

import java.util.function.*;

abstract class PartialFunction<X, Y> implements Predicate<X>, Function<X, Y> {
  public boolean isDefinedAt(X x) {
    return this.test(x);
  }
  public Y apply(X x) {
    if (isDefinedAt(x)) {
      return applyIfDefined(x);
    } else {
      throw new IllegalArgumentException("Match error on " + x);
    }
  }
  public abstract Y applyIfDefined(X x);

  public PartialFunction<X, Y> orElse(PartialFunction<X, Y> fallback) {
    PartialFunction<X, Y> outer = this;
    return new PartialFunction<X, Y>(){
      public boolean test(X x) {
        return outer.test(x) || fallback.test(x);
      }
      public Y applyIfDefined(X x) {
        if (outer.isDefinedAt(x)) {
          return outer.applyIfDefined(x);
        } else {
          return fallback.apply(x);
        }
      }
      @Override
      public Y apply(X x) {
        return applyIfDefined(x);
      }
    };
  }

  public static void main(String[] args) {
    PartialFunction<Integer, String> f = new PartialFunction<Integer, String>() {
      public boolean test(Integer i) {
        return i % 2 == 0;
      }
      public String applyIfDefined(Integer i) {
        return i + " is even";
      }
    };
    PartialFunction<Integer, String> g = new PartialFunction<Integer, String>() {
      public boolean test(Integer i) {
        return i % 2 == 1;
      }
      public String applyIfDefined(Integer i) {
        return i + " is odd";
      }
    };
    System.out.println(f.apply(42));
    try {
      System.out.println(f.apply(43));
    } catch (Exception e) {
      System.out.println(e);
    }
    PartialFunction<Integer, String> h = f.orElse(g);
    System.out.println(h.apply(100));
    System.out.println(h.apply(101));
  }
}

上面示例的输出是：

42 is even
java.lang.IllegalArgumentException: Match error on 43
100 is even
101 is odd

如果您想将其与某种“案例类”一起使用，也可以这样做，但是为此，您必须首先提供案例类的实现。