Qualcosa in Guava simile all'effetto funzionale di Java?

Question

So che uno degli obiettivi della pura programmazione funzionale è quello di eliminare la mutevolezza e quindi di escludere gli effetti collaterali. Ma ammettiamolo, Java non è un linguaggio funzionale nemmeno con tutte le librerie di programmazione funzionale esistenti. In effetti sembra che alcune delle librerie FP sappiano e si aspettano questo. Ad esempio in Java funzionale, esiste la classe Effect. Nella libreria Jedi FP, c'è l'interfaccia Command. Ciò consente, tra le altre cose, di applicare uno schema di comando con type-safety agli elementi di un Iterable senza il brutto hotporn del ciclo.

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

Quindi la domanda è, c'è qualcosa di simile in Guava?

modificato dopo risposta accettata PER CHIARIMENTI

Sto sviluppando un framework che aiuta con il "problema verticale" insito nella maggior parte dei Java FP-librerie, sotto un certo insieme di circostanze. Quindi vorrei non effettivamente fare l'esempio di codice come mostrato sopra: ad esempio, dichiaro esplicitamente una nuova implementazione di classe di Command con tutto il suo ickyness di rumore verticale, semplicemente allo scopo di applicarla immediatamente dopo la dichiarazione.

Stavo pensando più alle linee del modello di comando attuale, dove potrebbero esserci diversi possibili comandi dichiarati altrove, e solo uno di essi viene passato nel codice che vuole applicarlo iterativamente. Inoltre, l'obiettivo del mio framework è quello di rendere più idiomatico creare oggetti di interfaccia funzionale (funzioni, predicati, comandi, altri semplici lambda) senza spostare semplicemente il problema verticale altrove. Ho capito da tempo che questo non è nell'ambito di Guava. Ma come interfaccia di tipo Command sono disponibili in altre librerie FP, volevo solo sapere se esisteva un analogo in Guava.

Un esempio di codice più completo, utilizzando il mio quadro, potrebbe essere qualcosa di simile:

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(); 
    } 
} 

Answer 1

Nope!

Kevin Bourrillion, il responsabile del progetto Guava, ha detto sulle caratteristiche funzionali di Guava:

“La sintassi fa schifo. Allo stesso tempo, questa roba è ora, è sempre stata e sarà sempre nient'altro che una misura di stopgap fino a quando non potrà venire il giusto cambio di lingua, momento in cui finalmente potremo finalmente decidere la sintassi ottimale e avviare la programmazione in stile funzionale effettivamente rendere le vite migliori in Java per una volta. Quindi sono indeciso su quanti sforzi mettere nella roba della Funzione/Predicato; è nella biblioteca più perché sorta di doveva essere, non tanto perché pensiamo che sia un gioiello della corona “.

Ci sarà probabilmente cambiare la nostra strategia in modo significativo quando Java 8 arriva, ma che non sarà per un po 'ancora.

Inoltre, non abbiamo trovato molti casi d'uso per i quali riteniamo che l'interfaccia Command che descriveresti sarebbe la soluzione migliore. Ad esempio, pensiamo che il tuo codice sopra sarebbe molto meglio scritto come

for(PhoneNumber phone : phoneList) { 
    phone.call(); 
} 

alla vecchia maniera. Potremmo potenzialmente essere convinti del merito di Command, ma penso che il caso d'uso "per-ciascuno" sia quasi sempre fatto meglio alla vecchia maniera.