Java 8パターンマッチング？
Java 8はScalaのようなパターンマッチングをサポートし、他の機能的なプログラムはサポートしますか？Java 8's Lambda features。この特定の関数型プログラミングの概念については何も見つかりません。
関数型プログラミングに興味を持ったのは、特に命令型プログラミングの実装と比較して、クイックソートの実装でした。
文字列に正規表現を適用するという意味ではパターンマッチングについて話しているのではなく、 Haskellで適用 のように考えています。たとえば、ワイルドカードを使用します。
head (x:_) = x
tail (_:xs) = xs
Java 8はこれをネイティブにサポートしません。ただし、ラムダ式を使用すると、階乗を計算するために次のような方法があります。
public static int fact(int n) {
return ((Integer) new PatternMatching(
inCaseOf(0, _ -> 1),
otherwise( _ -> n * fact(n - 1))
).matchFor(n));
}
実装方法については、このブログの投稿 Javaでのパターンマッチングに向けて を参照してください。
Java 8（ラムダ式を利用する）でライブラリとしてパターンマッチングを実装することは可能ですが、残念ながら、HaskellやScalaあります。
Cyclops-react には強力な Pattern Matching モジュールがあり、Java 8の構造パターンマッチングとガードによるパターンマッチングの両方を提供します。
When/then/else DSLとマッチングを提供します。これには、分解を含めて、標準のJava述語に基づいているため、たとえば、マッチングを使用してストリームをフィルタリングできます）。
警備員によるマッチング
ガードを介したマッチングでは、whenGuard/then /を使用して、ケースがテスト対象であり、テスト対象のオブジェクトの構造ではないことを明確に示します。
例えばガードベースのマッチングの場合、Matchableインターフェースを実装するCaseクラスを実装すると
static class MyCase implements Matchable{ int a; int b; int c;}
（ところで、Lombokは密封されたケースクラス階層を作成するのに非常に便利です）
その内部値に一致させることができます（必要に応じて再帰的に、または他のさまざまなオプションのタイプごとに）。
import static com.aol.cyclops.control.Matchable.otherwise;
import static com.aol.cyclops.control.Matchable.whenGuard;
new MyCase(1,2,3).matches(c->c.is(whenGuard(1,2,3)).then("hello"),
.is(whenGuard(4,5,6)).then("goodbye")
,otherwise("goodbye")
);
[Matchable] [3]を実装しないオブジェクトがある場合は、とにかくそれをMatchableに強制できます。コードは次のようになります。
Matchable.ofDecomposable(()->new MyCase(1,2,3)))
.matches(c->c.is(whenGuard(1,2,3)).then("hello"),
.is(whenGuard(4,5,6)).then("goodbye")
,otherwise("hello"));
値の1つを気にしない場合は、ワイルドカードを使用できます
new MyCase(1,2,3).matches(c->c.is(whenGuard(1,__,3)).then("hello"),
.is(whenGuard(4,__,6)).then("goodbye")
,otherwise("hello)
);
または、ネストされたクラスのセットを再帰的に分解する
Matchable.of(new NestedCase(1,2,new NestedCase(3,4,null)))
.matches(c->c.is(whenGuard(1,__,has(3,4,__)).then("2")
,otherwise("default");
NestedCaseは次のようになります-
class NestedCase implemends Decomposable { int a; int b; NestedCase c; }
ユーザーは、hamcrestを使用してパターンマッチング式を作成することもできます
import static com.aol.cyclops.control.Matchable.otherwise;
import static com.aol.cyclops.control.Matchable.then;
import static com.aol.cyclops.control.Matchable.when;
Matchable.of(Arrays.asList(1,2,3))
.matches(c->c.is(when(equalTo(1),any(Integer.class),equalTo(4)))
.then("2"),otherwise("default"));
構造パターンマッチング
テストするオブジェクトの正確な構造に一致させることもできます。それはif/thenテストを使用するのではなく、構造がたまたま私たちのケースと一致するかどうかを確認するために、コンパイラーに提供されたオブジェクトの構造と一致するかどうかをコンパイラーに確認させることができます。これを行うためのDSLは、ガードベースのマッチングとほぼ同じですが、オブジェクト構造がテストケースを駆動し、その逆ではないことを明確にするために///を使用します。
import static com.aol.cyclops.control.Matchable.otherwise;
import static com.aol.cyclops.control.Matchable.then;
import static com.aol.cyclops.control.Matchable.when;
String result = new Customer("test",new Address(10,"hello","my city"))
.match()
.on$_2()
.matches(c->c.is(when(decons(when(10,"hello","my city"))),then("hello")), otherwise("miss")).get();
//"hello"
顧客から抽出した住所オブジェクトを構造的に照合します。 CustomerクラスとAddressクラスがこれを見るところ、これは
@AllArgsConstructor
static class Address{
int house;
String street;
String city;
public MTuple3<Integer,String,String> match(){
return Matchable.from(()->house,()->street,()->city);
}
}
@AllArgsConstructor
static class Customer{
String name;
Address address;
public MTuple2<String,MTuple3<Integer,String,String>> match(){
return Matchable.from(()->name,()->Maybe.ofNullable(address).map(a->a.match()).orElseGet(()->null));
}
}
cyclops-reactは Matchables クラスを提供し、一般的なJDKタイプに対する構造パターンマッチングを可能にします。
この質問には既に回答済みであることを認識しています。さらに、関数型プログラミングは初めてですが、ためらいがちになったため、ついにこのディスカッションに興味を持ち、その後のフィードバックを得ることにしました。
以下の（あまりにも）単純な実装をお勧めします。受け入れられた回答で引用された（Nice）記事とは少し異なります。しかし、私の（短い）経験では、使用するのが少し柔軟で、保守が簡単でした（もちろん、好みの問題でもあります）。
import Java.util.Optional;
import Java.util.function.Function;
import Java.util.function.Predicate;
final class Test
{
public static final Function<Integer, Integer> fact = new Match<Integer>()
.caseOf( i -> i == 0, i -> 1 )
.otherwise( i -> i * Test.fact.apply(i - 1) );
public static final Function<Object, String> dummy = new Match<Object>()
.caseOf( i -> i.equals(42), i -> "forty-two" )
.caseOf( i -> i instanceof Integer, i -> "Integer : " + i.toString() )
.caseOf( i -> i.equals("world"), i -> "Hello " + i.toString() )
.otherwise( i -> "got this : " + i.toString() );
public static void main(String[] args)
{
System.out.println("factorial : " + fact.apply(6));
System.out.println("dummy : " + dummy.apply(42));
System.out.println("dummy : " + dummy.apply(6));
System.out.println("dummy : " + dummy.apply("world"));
System.out.println("dummy : " + dummy.apply("does not match"));
}
}
final class Match<T>
{
public <U> CaseOf<U> caseOf(Predicate<T> cond, Function<T, U> map)
{
return this.new CaseOf<U>(cond, map, Optional.empty());
}
class CaseOf<U> implements Function<T, Optional<U>>
{
private Predicate<T> cond;
private Function<T, U> map;
private Optional<CaseOf<U>> previous;
CaseOf(Predicate<T> cond, Function<T, U> map, Optional<CaseOf<U>> previous)
{
this.cond = cond;
this.map = map;
this.previous = previous;
}
@Override
public Optional<U> apply(T value)
{
Optional<U> r = previous.flatMap( p -> p.apply(value) );
return r.isPresent() || !cond.test(value) ? r
: Optional.of( this.map.apply(value) );
}
public CaseOf<U> caseOf(Predicate<T> cond, Function<T, U> map)
{
return new CaseOf<U>(cond, map, Optional.of(this));
}
public Function<T,U> otherwise(Function<T, U> map)
{
return value -> this.apply(value)
.orElseGet( () -> map.apply(value) );
}
}
}
Derive4J は、Java（およびそれ以上）の合計タイプおよび構造パターンマッチングのネイティブに近いサポートをサポートすることを目的とするライブラリです。例として小さな計算機DSLを使用します。 、Derive4Jを使用すると、次のコードを記述できます。
import Java.util.function.Function;
import org.derive4j.Data;
import static org.derive4j.exemple.Expressions.*;
@Data
public abstract class Expression {
interface Cases<R> {
R Const(Integer value);
R Add(Expression left, Expression right);
R Mult(Expression left, Expression right);
R Neg(Expression expr);
}
public abstract <R> R match(Cases<R> cases);
private static Function<Expression, Integer> eval = Expressions
.match()
.Const(value -> value)
.Add((left, right) -> eval(left) + eval(right))
.Mult((left, right) -> eval(left) * eval(right))
.Neg(expr -> -eval(expr));
public static Integer eval(Expression expression) {
return eval.apply(expression);
}
public static void main(String[] args) {
Expression expr = Add(Const(1), Mult(Const(2), Mult(Const(3), Const(3))));
System.out.println(eval(expr)); // (1+(2*(3*3))) = 19
}
}
これは、Java 8.の構造パターンの加工に関する興味深い記事です。最後に簡単に実装できることを示しています。
http://blog.higher-order.com/blog/2009/08/21/structural-pattern-matching-in-Java/