Guava中的任何东西都类似于Functional Java的效果？

我知道纯函数式编程的目标之一是消除可变性，从而排除副作用。但是让我们面对现实吧，即使存在所有的函数式编程库，Java也不是一种函数式语言。事实上，似乎有些FP库知道并期待这一点。例如，在Functional Java中，有 效果 类。在Jedi FP库中，有 Command 界面。这允许您 - 除其他外 - 将类型安全的命令模式应用于 Iterable 的元素，而不需要讨厌的for循环样板。

I know one of the goals of pure functional programming is to eliminate mutability, and therefore to preclude side-effects. But let's face it, Java is not a functional language even with all of the functional-programming libraries that exist. In fact it seems that some of the FP-libraries know and expect this. For instance in Functional Java, there is the Effect class. In the Jedi FP library, there is the Command interface. This allows you to -- among other things -- apply a command pattern with type-safety to elements of an Iterable without the nasty for-loop boilerplate.

Command<PhoneNumber> makeCall = new Command<PhoneNumber> {
    public void execute(PhoneNumber p) { p.call(); }
}
List<PhoneNumber> phoneList = ...
FunctionalPrimitives.forEach( phoneList, makeCall );

所以问题是，番石榴中有类似的东西吗？

So the question is, is there anything like that in Guava?

在接受澄清后接受回复

我正在开发框架，有助于解决大多数Java FP库中固有的垂直问题，在某些情况下。所以我 not 实际上是如上所示的代码示例：即明确声明一个新的类实现 Command 及其所有垂直噪声icky-ness，只是为了在声明之后立即应用它。

I am developing a framework that helps with the "vertical problem" inherent in most Java FP-libraries, under a certain set of circumstances. So I would not actually make the code example as shown above: i.e., explicitly declare a new class implementation of Command with all of its vertical-noise icky-ness, simply for the purpose of immediately applying it right after the declaration.

我在考虑实际命令模式的方式更多，其中可能有几个可能的命令在其他地方声明，并且只有其中一个被传递到想要迭代应用它的代码中。此外，我的框架的目标是使创建功能接口对象（函数，谓词，命令，其他简单的lambda）更加惯用，而不是简单地将垂直问题移动到其他地方。我早就意识到这不在番石榴的范围内。但是由于其他FP库中有类似Command的接口，我只是想知道Guava中是否存在模拟。

I was thinking more along the lines of the actual command pattern, where there may be several possible commands declared elsewhere, and only one of them gets passed into the code which wants to apply it iteratively. Furthermore, the goal of my framework is to make it more idiomatic to create functional-interface objects (functions, predicates, commands, other simple lambdas) without simply moving the vertical problem elsewhere. I have long realized this is not within the scope of Guava. But as Command-like interface are available in other FP libraries, I just wanted to know if an analog existed in Guava.

一个更完整的代码示例，使用我的框架，可能是这样的：

A more complete code example, using my framework, might be something like this:

class Stuff {
    private final Stuff CALLS_TO = callsTo(Stuff.class); // a proxy
    public static final Command<Stuff> CMD1 = commandFor(CALLS_TO.someMethod1());
    public static final Command<Stuff> CMD2 = commandFor(CALLS_TO.someMethod2());

    // methods exist for use elsewhere, but are conveniently also wrapped as commands
    public void someMethod1() {...}
    public void someMethod2() {...}
}

class Activity {
    public void handleIt(List<Stuff> stuffs, Command<Stuff> doCmd) {
        doSomeThings();
        ...
        forEach(stuffs, doCmd);
        ...
        doOtherThings();
    }
}