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.Qualcosa in Guava simile all'effetto funzionale di Java?
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();
}
}
Perché il modo "vecchio stile" è migliore per i comandi, ma non meglio per i filtri e le trasformazioni? Inoltre, so che le funzionalità sono viste come interruzioni fino a Java 8, ma è necessario rendersi conto che Java 8 è un po 'di tempo libero e l'adozione non sarà immediata. Ci sono ancora progetti bloccati in Java 5 (per fortuna, non mio). –
Se leggi [la guida per l'utente] (http://code.google.com/p/guava-libraries/wiki/FunctionalExplained#Caveats), vedrai che pensiamo che la vecchia maniera è meglio per i filtri e trasformazioni la maggior parte del tempo. Non tutto il tempo - ecco perché forniamo queste funzionalità - ma la maggior parte del tempo. –
Inoltre, il codice del post originale sembra essere un esempio di ciò che rende [il guava team weep] (http://code.google.com/p/guava-libraries/wiki/FunctionalExplained). –