Map è una funzione che applica un'altra funzione a tutti gli elementi di un elenco, per produrre un altro elenco con tutti i valori di ritorno su di esso. (Un altro modo per dire "applica f a x" è "chiama f, passandola x". Quindi a volte suona meglio dire "applica" invece di "chiama".)
Questo è il modo in cui la mappa è probabilmente scritta in C # (si chiama Selected è nella libreria standard):
public static IEnumerable<R> Select<T, R>(this IEnumerable<T> list, Func<T, R> func)
{
foreach (T item in list)
yield return func(item);
}
Dato che sei un tizio di Java, e Joel Spolsky ama raccontare BUGIE GRAVOSAMENTE INGIUSTE su quanto sia schifoso Java (in realtà, non sta mentendo, è schifoso, ma sto cercando di conquistarti), ecco il mio tentativo molto approssimativo di una versione Java (non ho un compilatore Java e ricordo vagamente la versione 1.1 di Java!):
// represents a function that takes one arg and returns a result
public interface IFunctor
{
object invoke(object arg);
}
public static object[] map(object[] list, IFunctor func)
{
object[] returnValues = new object[list.length];
for (int n = 0; n < list.length; n++)
returnValues[n] = func.invoke(list[n]);
return returnValues;
}
Sono sicuro che questo può essere migliorato in un milione di modi. Ma è l'idea di base.
Riduci è una funzione che trasforma tutti gli elementi di un elenco in un unico valore. Per fare ciò, è necessario assegnare un'altra funzione funcche trasforma due elementi in un unico valore. Funzionerebbe dando i primi due elementi a func. Quindi il risultato di quello insieme al terzo elemento. Quindi il risultato di ciò con il quarto elemento e così via fino a quando tutti gli elementi non sono stati eliminati e ci rimane un valore.
In C # viene chiamato reduce Aggregateed è di nuovo nella libreria standard. Salterò direttamente a una versione Java:
// represents a function that takes two args and returns a result
public interface IBinaryFunctor
{
object invoke(object arg1, object arg2);
}
public static object reduce(object[] list, IBinaryFunctor func)
{
if (list.length == 0)
return null; // or throw something?
if (list.length == 1)
return list[0]; // just return the only item
object returnValue = func.invoke(list[0], list[1]);
for (int n = 1; n < list.length; n++)
returnValue = func.invoke(returnValue, list[n]);
return returnValue;
}
Queste versioni di Java richiedono l'aggiunta di generici, ma non so come farlo in Java. Ma dovresti essere in grado di passare loro classi interne anonime per fornire i funtori:
string[] names = getLotsOfNames();
string commaSeparatedNames = (string)reduce(names,
new IBinaryFunctor {
public object invoke(object arg1, object arg2)
{ return ((string)arg1) + ", " + ((string)arg2); }
}
Si spera che i generici si sbarazzino dei calchi. L'equivalente typesafe in C # è:
string commaSeparatedNames = names.Aggregate((a, b) => a + ", " + b);
Perché questo "cool"? Semplici modi per suddividere calcoli più grandi in pezzi più piccoli, in modo che possano essere rimessi insieme in modi diversi, sono sempre interessanti. Il modo in cui Google applica questa idea è la parallelizzazione, perché sia la mappa che la riduzione possono essere condivise su più computer.
Ma il requisito fondamentale NON è che la tua lingua possa trattare le funzioni come valori. Qualsiasi lingua OO può farlo. Il requisito effettivo per la parallelizzazione è che le piccole funcfunzioni passate per mappare e ridurre non devono utilizzare o aggiornare alcuno stato. Devono restituire un valore che dipende solo dagli argomenti loro passati. Altrimenti, i risultati saranno completamente sbagliati quando proverai a eseguire il tutto in parallelo.