函数组合中的条件操作

Question

如何根据某些逻辑条件停止或分支合成？

例如。假设我有以下代码：

compose(
  operation4
  operation3,
  operation2,
  operation1
)(myStuff);

甚至是类似的东西

myStuff
 .map(operation1)
 .map(operation2)
 .map(operation3)
 .map(operation4)

如果 myStuff 满足某些条件，我只希望执行操作 3 和 4。

我该如何实现（特别是在 JavaScript 中）？

我是否必须创建两个较小的组合并有一个单独的 if 语句，或者有没有办法在组合中包含条件？

Monads 能解决我的问题吗？如果有，怎么做？

Answer 1

一个简单但实​​用的方法是有一个像when(cond, f) 这样的函数，它只在cond(x) 返回true 时执行f（这又可以是一个组合）：

_do = (...fns) => x => fns.reduce((r, f) => f(r), x);
_when = (cond, f) => x => cond(x) ? f(x) : x;


// example

add3 = x => x + 3;
add5 = x => x + 5;
add9 = x => x + 9;


pipe = _do(
    add3,
    add5,
    _when(x => x > 20, _do(add9))
)


console.log(pipe(30))
console.log(pipe(1))

Answer 2

过早退出组合

这至少是可能的，但我认为这不是一个好主意。函数组合旨在表现得像单个函数。这是一个原子操作。因此，不提供开箱即用的过早退出。

让我们后退一步。 n 函数的组合是经典的归约：

// generic functions

const foldr = f => acc => xs =>
 xs.reduceRight((acc, x, i) => f(x) (acc, i), acc);

const comp = f => g => x => f(g(x));

const I = x => x;

const inc = x => x + 1;

// derived function

const compn = foldr(comp) (I);


// run

console.log(
  compn([inc, inc, inc, inc]) (0) // 4
);

compn 产生类似的计算：

const I = x => x;

const inc = x => x + 1;

const computation = x => inc(inc(inc(inc(I(x)))));

console.log(
  computation(0) // 4
);

如果我们想提前退出组合，我们必须同时适应迭代算法 (foldr) 和组合 (compn)：

// generic functions

const foldrk = f => acc => xs => {
  const next = (i, acc) => i < 0
   ? acc
   : f(xs[i], i) (acc) (acc => next(i - 1, acc));

  return next(xs.length - 1, acc);
};

const I = x => x;

const comp = f => g => x => f(g(x));

const inc = x => x + 1;

const lt = y => x => x < y;


// derived function

compWhile = pred => foldrk(f => acc => k => k(
  x => pred(x) 
   ? comp(acc) (f) (x) 
   : x
)) (I);


// run

console.log(
  compWhile(lt(2)) ([inc, inc, inc, inc]) (0) // 2
);

只要当前返回值小于 2，组合就会继续。代码很难推理。我什至不试图解释它（这不值得努力）。无论如何，compWhile 会产生以下计算：

const comp = f => g => x => f(g(x));

const I = x => x;

const inc = x => x + 1;

const lt = y => x => x < y;

const lt2 = lt(2);

const computation = x => lt2(x) 
 ? comp(x => lt2(x)
  ? comp(x => lt2(x)
   ? comp(x => lt2(x)
    ? comp(I) (inc) (x)
    : x) (inc) (x)
   : x) (inc) (x)
  : x) (inc) (x)
 : x;


console.log(
  computation(0) // 2
);

分支组合

只需将组合分成更小的组合，它们代表所需的分支。如果你尝试编写条件函数，你将不可避免地得到不可读的代码。

如果你只有一个简单的条件并且你不想拆分你的组合，至少使分支尽可能明确，例如使用条件运算符:?：

const foldr = f => acc => xs =>
 xs.reduceRight((acc, x, i) => f(x) (acc, i), acc);

const comp = f => g => x => f(g(x));

const I = x => x;

const inc = x => x + 1;

const compn = foldr(comp) (I);


console.log(
  compn([x => x >= 2 ? x : inc(x), inc, inc]) (0) // 2
);

结论

函数组合是一种原子操作。不要试图过早退出或从组合中分支。

Answer 3

我可能在一定程度上误解了这个问题，但这听起来像是你可以用数组或流做的事情，例如，用反应式流或任何其他类似的库。

var myStuff = "one";
[myStuff]
  .filter(text => text.length <= 3)
  .map(text => text.split('').reverse().join(''))
  .map(text => text.toUpperCase())
  .forEach(text => console.log(text)); //prints ENO

或者使用像RxJS这样的流库。

Rx.Observable.of("one","two","three")
            .filter(text => text.length <= 3)
            .map(text => text.split('').reverse().join(''))
            .map(text => text.toUpperCase())
            .forEach(text => console.log(text)); //prints ENO, OWT

除非满足过滤条件，否则上述两个示例数据都不会流向反转和大写操作，这似乎是您要问的。

虽然这很明显，但我感觉您的问题可能与其他问题有关。无论哪种情况，我都希望这有助于讨论。

Answer 4

只需在每一步之后分析您的 someObject。带有条件回调的示例，但您可以通过不同的方式实现此检查。

function compose(...fns) {
    return function (result, conditionCallback) {
        for (var i = fns.length - 1; i > -1; i--) {
            result = fns[i].call(this, result);

            // Run here condition check if provided.
            if (conditionCallback && conditionCallback(result) === false) {
                return result;
            }
        }
        return result;
    };
};

compose(...functionList)(someObject, function(obj) {
    return obj.prop !== someValue;
});

PS：我希望理解正确，你在“构图”下是什么意思。

PPS：示例使用 ES6 特性，但降级到 ES5 非常简单。