Question

我试图尝试使用lambdas来获得乐趣。我创建了一个functor，它允许组合lambda。但是，组合方式只允许线性变换，并且不允许分支。

我的想法是，我知道将来会有一个有效的不可变状态数据结构。我想组成一个从状态中提取值的变换;并将执行一系列步骤，这些步骤可能需要也可能不需要状态，以执行转换。

为此，我创建了两个类。函数接口的作用类似于java.util.function.Function，但在andThen方法中采用BiFunction，它允许将state参数从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);

有没有人对如何在branch上实现ProcedureContainer方法有任何想法，这种方法允许在执行最终消费者时使用条件分支。我正在考虑使这个例子有用的东西：

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方法。这个问题是我不知道如何以只有分支运行的方式合并两个分支。

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

Answer 1

我能够把解决方案放在一起。但是，我发现它并不特别优雅。因此，请随时提交其他解决方案（或此解决方案的更多重要原因）。

我最初尝试创建一个状态容器，其中包含一个布尔值，说明是否使用了特定的分支。这是一个禁忌，因为国家没有正确传递。所以，我创建了一个值容器：

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
}

然后我重写了功能界面以使用新容器：

@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方法;并重新设计terminate方法以考虑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。

注意：据我所知，我已经使用'terminate'来指定分支何时完成，以及何时从不运行分支。我仍然在考虑一个更好的命名约定。接受建议。

从其他lambda组成lambda时分支

1 个答案: