Соответствие шаблону Java 8?

Ответ 1

Я предполагаю, что вы не говорите о совпадении шаблонов в смысле применения регулярного выражения в строке, а как применяемом в Haskell. Например, используя подстановочные знаки:

head (x:_)  = x
tail (_:xs) = xs

Java 8 не поддерживает это изначально, но с помощью выражения Lambda существуют способы сделать это, например, для вычисления факториала:

public static int fact(int n) {
     return ((Integer) new PatternMatching(
          inCaseOf(0, _ -> 1),
          otherwise(  _ -> n * fact(n - 1))
     ).matchFor(n));
}

Как реализовать это, вы найдете дополнительную информацию в этом блоге: На пути к сопоставлению с образцом в Java.

Ответ 2

Возможно реализовать сопоставление образцов в виде библиотеки в Java 8 (используя выражения лямбда-выражения), но, к сожалению, мы все равно будем пропускать проверку полноты компилятора, чтобы такие языки, как Haskell или Scala, имели.

Cyclops-react имеет мощный шаблон соответствия > модуль, который предлагает как структурное сопоставление шаблонов для Java 8, так и сопоставление образцов с помощью защитных устройств.

Он предоставляет, когда /then/other DSL и сопоставление, включая деконструкцию, основаны на стандартных Java-предикатах (так что сопоставление может быть использовано для фильтрации потока, например).

Согласование с помощью охранников

Для сопоставления с помощью защитных устройств мы используем whenGuard/then/other, чтобы ясно показать, что этот случай управляет тестом, а не структурой объекта, находящегося под тестом.

например. Для сопоставления с защитой, если мы реализуем класс Case, который реализует интерфейс Matchable

 static class MyCase  implements Matchable{ int a; int b; int c;}

(btw, 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"));

Если мы не заботимся об одном из значений, мы можем использовать подстановочные знаки

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"));

Сопоставление структурных шаблонов

Мы также можем сопоставлять точную структуру тестируемого объекта. Это скорее, чем использование, если /then проверяет, соответствует ли структура нашей ситуации, мы можем заставить компилятор убедиться, что наши случаи соответствуют структуре предоставленных объектов. DSL, чтобы сделать это, почти идентичен в соответствии с соглашением на основе защиты, но мы используем, когда /then/other ясно показывает, что структура объектов управляет тестовыми примерами, а не наоборот.

  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.

Ответ 3

Я знаю, что на этот вопрос уже был дан ответ, кроме того, я новичок в функциональном программировании, но после долгих колебаний я, наконец, решил пригласить в эту дискуссию обратную связь о том, что следует.

Я бы предложил следующую (слишком?) простую реализацию ниже. Он немного отличается от (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) );
        }
    }
}

Ответ 4

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
    }
}

Ответ 5

Вот интересная статья о структурной обработке шаблонов в Java 8. Она предлагает простую реализацию в конце.

http://blog.higher-order.com/blog/2009/08/21/structural-pattern-matching-in-java/