Map est une fonction qui applique une autre fonction à tous les éléments d'une liste, pour produire une autre liste avec toutes les valeurs de retour dessus. (Une autre façon de dire "appliquer f à x" est "appeler f, en lui passant x". Donc, parfois, il semble plus agréable de dire "appliquer" au lieu de "appeler".)
Voici comment la carte est probablement écrite en C # (elle est appelée Selectet se trouve dans la bibliothèque 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);
}
Comme vous êtes un mec Java, et que Joel Spolsky aime dire à DES MENSONGES GROSSEMENT INJUSTE à quel point Java est merdique (en fait, il ne ment pas, c'est merdique, mais j'essaie de vous convaincre), voici ma tentative très difficile de une version Java (je n'ai pas de compilateur Java, et je me souviens vaguement de la version 1.1 de 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;
}
Je suis sûr que cela peut être amélioré de mille façons. Mais c'est l'idée de base.
Réduire est une fonction qui transforme tous les éléments d'une liste en une seule valeur. Pour ce faire, il doit être doté d'une autre fonction funcqui transforme deux éléments en une seule valeur. Cela fonctionnerait en donnant les deux premiers éléments à func. Puis le résultat de cela avec le troisième élément. Ensuite, le résultat de cela avec le quatrième élément, et ainsi de suite jusqu'à ce que tous les éléments aient disparu et qu'il nous reste une valeur.
En C #, la réduction est appelée Aggregateet est à nouveau dans la bibliothèque standard. Je vais passer directement à une version 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;
}
Ces versions de Java ont besoin d'être ajoutées à des génériques, mais je ne sais pas comment faire cela en Java. Mais vous devriez pouvoir leur passer des classes internes anonymes pour fournir les foncteurs:
string[] names = getLotsOfNames();
string commaSeparatedNames = (string)reduce(names,
new IBinaryFunctor {
public object invoke(object arg1, object arg2)
{ return ((string)arg1) + ", " + ((string)arg2); }
}
Espérons que les génériques élimineraient les moulages. L'équivalent typeafe en C # est:
string commaSeparatedNames = names.Aggregate((a, b) => a + ", " + b);
Pourquoi est-ce «cool»? Les moyens simples de diviser des calculs plus volumineux en petits morceaux, afin qu'ils puissent être reconstitués de différentes manières, sont toujours intéressants. Google applique cette idée à la parallélisation, car la carte et la réduction peuvent être partagées sur plusieurs ordinateurs.
Mais l'exigence clé n'est PAS que votre langage puisse traiter les fonctions comme des valeurs. N'importe quel langage OO peut le faire. L'exigence réelle pour la parallélisation est que les petites funcfonctions que vous passez à mapper et à réduire ne doivent utiliser ou mettre à jour aucun état. Ils doivent renvoyer une valeur qui dépend uniquement du ou des arguments qui leur sont passés. Sinon, les résultats seront complètement foirés lorsque vous essayez d'exécuter le tout en parallèle.