我正在尝试使用 lambda 来获得乐趣。我创建了一个允许 lambda 组合的仿函数。但是，组合方式只允许线性变换，不允许分支。

我的想法是，我知道我将来会拥有一个有效的不可变状态数据结构。我想编写一个从状态中提取值的转换；并将执行一系列步骤(可能需要也可能不需要状态)来执行转换。

为此，我创建了两个类。函数式接口(interface)的工作方式类似于 java.util.function.Function，但在 andThen 方法中采用了一个 BiFunction，它允许状态参数从 lambda 传递到 lambda。

import java.util.Objects;
import java.util.function.BiFunction;

@FunctionalInterface
public interface Procedure<S, T> {

    T procede(S stateStructure);

    default <R> Procedure<S, R> andThen(BiFunction<S, T, R> after) {
        Objects.requireNonNull(after);
        return (param) -> after.apply(param, procede(param));
    }
}

仿函数非常简单，有两个映射函数(一个使用状态，一个不使用)，以及两个完成转换的终止方法(同样，有状态和没有状态)。

import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;

public class ProcedureContainer<S, T> {

    protected final Procedure<S, T> procedure;

    protected ProcedureContainer(final Procedure<S, T> procedure) {
        this.procedure = procedure;
    }

    public static <S, R> ProcedureContainer<S, R> initializeContainer(
            final Function<S, R> initialDataRetriever) {

        return new ProcedureContainer<>(initialDataRetriever::apply);
    }

    public <R> ProcedureContainer<S, R> map(final BiFunction<S, T, R> mapper) {
        return new ProcedureContainer<>(procedure.andThen(mapper));
    }

    public <R> ProcedureContainer<S, R> map(final Function<T, R> mapper) {
        BiFunction<S, T, R> subMapper =
                (ignored, stagedData) -> mapper.apply(stagedData);
        return new ProcedureContainer<>(procedure.andThen(subMapper));
    }

    public Consumer<S> terminate(final BiConsumer<S, T> consumer) {
        return (param) -> consumer.accept(param, procedure.procede(param));
    }

    public Consumer<S> terminate(final Consumer<T> consumer) {
        return (param) -> consumer.accept(procedure.procede(param));
    }
}

一个简短的(人为的)例子:

StateStruct state = new StateStruct();
state.setJson("{\"data\":\"meow, meow, I'm a cow\"}");
state.setRequestedField("data");

Consumer<StateStruct> consumer = ProcedureContainer
    .initializeContainer(SateStruct::getJson)
    .map(JSONObject::new)
    .map((state, jsonObj) -> jsonObject.getString(state.getRequsetedField()))
    .terminate(System.out::singLoudly);

consumer.accept(state);

有没有人知道我如何在 ProcedureContainer 上实现 branch 方法，从而允许在最终使用者的执行中有条件分支。我在想一些能让这个例子起作用的东西:

StateStruct state = new StateStruct();
state.setJson("{\"data\":\"meow, meow, I'm a cow\"}");
state.setRequestedField("data");
state.setDefaultMessage("There is no data... only sheep");

Consumer<StateStruct> consumer = ProcedureContainer
    .initializeContainer(SateStruct::getJson)
    .map(JSONObject::new)

    .branch((state, jsonObj) -> !jsonObject.getString(state.getRequsetedField()))
    .terminateBranch((state, json) -> System.out.lament(state.getDefaultMessage()))

    .map((state, jsonObj) -> jsonObject.getString(state.getRequsetedField()))
    .terminate(System.out::singLoudly);

consumer.accept(state);

我尝试创建一个新的 BranchProcedureContainer，它有一个 map 和 terminateBranch 方法。这个问题是我不知道如何以只有分支运行的方式合并两个分支。

创建新类或向现有类添加方法没有任何限制。

最佳答案

我能够将解决方案放在一起。但是，我并不觉得它特别优雅。因此，请随时提交其他解决方案(或此解决方案的更巧妙版本)。

我最初尝试创建一个状态容器，其中包含一个 boolean 值，说明是否使用了特定分支。这是不行的，因为状态没有正确传递。因此，我创建了一个值容器:

class ValueContainer<T> {

    private final T value;
    private final Boolean terminated;

    private ValueContainer(final T value, final Boolean terminated) {
        this.value = value;
        this.terminated = terminated;
    }

    public static <T> ValueContainer<T> of(final T value) {
        return new ValueContainer<>(value, false);
    }

    public static <T> ValueContainer<T> terminated() {
        return new ValueContainer<>((T) null, true);
    }

    //...getters
}

然后我重写了功能接口(interface)以使用新容器:

@FunctionalInterface
public interface Procedure<S, T> {

    ValueContainer<T> procede(S stateStructure);
}

通过添加 ValueContainer，我不希望用户为每个方法解包值。因此，扩展了默认方法以考虑容器。此外，添加了逻辑来处理过程是未使用/终止分支的一部分的情况。

default <R> Procedure<S, R> andThen(BiFunction<S, T, R> after) {
    Objects.requireNonNull(after);
    return (param) -> {
        ValueContainer<T> intermediateValue = procede(param);
        if (intermediateValue.isTerminated())
            return ValueContainer.<R>terminated();
        R returnValue = after.apply(param, intermediateValue.getValue());
        return ValueContainer.of(returnValue);
    };
}

从那里开始，我只需要扩展 ProcedureContainer 以拥有一个 branch 方法；并重新设计了终止方法以解决 ValueContainer 和终止分支的情况。 (下面的代码省略了重载方法)

public class ProcedureContainer<S, T> {

    protected final Procedure<S, T> procedure;

    protected ProcedureContainer(final Procedure<S, T> procedure) {
        this.procedure = procedure;
    }

    public static <S, R> ProcedureContainer<S, R> initializeContainer(
            final Function<S, R> initialDataRetriever) {

        Procedure<S, R> initializer = (paramContainer) -> {
            R initialValue = initialDataRetriever.apply(paramContainer);
            return ValueContainer.of(initialValue);
        };
        return new ProcedureContainer<>(initializer);
    }

    public <R> ProcedureContainer<S, R> map(final BiFunction<S, T, R> mapper) {
        return new ProcedureContainer<>(procedure.andThen(mapper));
    }

    public BranchProcedureContainer<S, T, T> branch(final BiPredicate<S, T> predicate) {

        return BranchProcedureContainer.branch(procedure, predicate);
    }

    public Consumer<S> terminate(final BiConsumer<S, T> consumer) {
        return (param) -> {
            ValueContainer<T> finalValue = procedure.procede(param);
            if (finalValue.isTerminated())
                return;

            consumer.accept(param, finalValue.getValue());
        };
    }
}

branch 方法返回一个新类 BranchProcedureContainer，它负责构建分支。此类有一个 endBranch 方法，它与 ProcedureContainer 的新实例相关联。 (同样，重载方法被忽略)

public class BranchProcedureContainer<S, T, R> {

    private final Procedure<S, T> baseProcedure;
    private final BiPredicate<S, T> predicate;
    private final BiFunction<S, ValueContainer<T>, ValueContainer<R>> branchProcedure;

    private BranchProcedureContainer(
            final Procedure<S, T> baseProcedure,
            final BiPredicate<S, T> predicate,
            final BiFunction<S, ValueContainer<T>, ValueContainer<R>> branchProcedure) {

        this.baseProcedure = baseProcedure;
        this.predicate = predicate;
        this.branchProcedure = branchProcedure;
    }

    protected static <S, T> BranchProcedureContainer<S, T, T> branch(
            final Procedure<S, T> baseProcedure,
            final BiPredicate<S, T> predicate) {

        return new BranchProcedureContainer<>(baseProcedure, predicate, (s, v) -> v);
    }

    public <RR> BranchProcedureContainer<S, T, RR> map(
            final BiFunction<S, R, RR> mapper) {

        BiFunction<S, ValueContainer<T>, ValueContainer<RR>> fullMapper = (s, vT) -> {
            if (vT.isTerminated())
                return ValueContainer.<RR>terminated();

            ValueContainer<R> intermediateValue = branchProcedure.apply(s, vT);
            if (intermediateValue.isTerminated())
                return ValueContainer.<RR>terminated();

            RR finalValue = mapper.apply(s, intermediateValue.getValue());
            return ValueContainer.of(finalValue);
        };
        return new BranchProcedureContainer<>(baseProcedure, predicate, fullMapper);
    }

    public ProcedureContainer<S, T> endBranch(final BiConsumer<S, R> consumer) {

        Procedure<S, T> mergedBranch = (state) -> {
            ValueContainer<T> startingPoint = baseProcedure.procede(state);
            if (startingPoint.isTerminated())
                return ValueContainer.<T>terminated();

            if (!predicate.test(state, startingPoint.getValue()))
                return startingPoint;

            ValueContainer<R> intermediateValue = branchProcedure.apply(state, startingPoint);
            if (intermediateValue.isTerminated())
                return ValueContainer.<T>terminated();
            consumer.accept(state, intermediateValue.getValue());
            return ValueContainer.<T>terminated();
        };

        return new ProcedureContainer<>(mergedBranch);
    }
}

我发现这种方法的一个问题(虽然我确信有很多)是重复调用以确定分支是否终止。如果只在分支点进行检查就好了。

可以找到完整的代码my github page .

注意:我知道我使用“终止”来指定分支何时完成，以及分支何时永远不会运行。我仍在努力想出一个更好的命名约定。接受建议。

关于java - 从其他 lambda 组合 lambda 时分支，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44219617/