Map ist eine Funktion, die eine andere Funktion auf alle Elemente in einer Liste anwendet, um eine weitere Liste mit allen Rückgabewerten zu erstellen. (Eine andere Möglichkeit, "f auf x anwenden" zu sagen, ist "f aufrufen, x übergeben". Manchmal klingt es also besser, "anwenden" anstelle von "aufrufen" zu sagen.)
So wird map wahrscheinlich in C # geschrieben (es heißt Selectund befindet sich in der Standardbibliothek):
public static IEnumerable<R> Select<T, R>(this IEnumerable<T> list, Func<T, R> func)
{
foreach (T item in list)
yield return func(item);
}
Da Sie ein Java-Typ sind und Joel Spolsky GROSSLY UNFAIR LIES gerne erzählt, wie beschissen Java ist (eigentlich lügt er nicht, es ist beschissen, aber ich versuche, Sie für sich zu gewinnen), ist hier mein sehr grober Versuch eine Java-Version (Ich habe keinen Java-Compiler und erinnere mich vage an Java-Version 1.1!):
// 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;
}
Ich bin sicher, dass dies auf millionenfache Weise verbessert werden kann. Aber es ist die Grundidee.
Reduzieren ist eine Funktion, die alle Elemente in einer Liste in einen einzigen Wert umwandelt. Dazu muss eine andere Funktion funczugewiesen werden, die zwei Elemente in einen einzigen Wert verwandelt. Es würde funktionieren, wenn man die ersten beiden Punkte an gibt func. Dann das Ergebnis davon zusammen mit dem dritten Punkt. Dann das Ergebnis davon mit dem vierten Element und so weiter, bis alle Elemente verschwunden sind und wir einen Wert haben.
In C # wird reduzieren aufgerufen Aggregateund befindet sich wieder in der Standardbibliothek. Ich werde direkt zu einer Java-Version springen:
// 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;
}
Diese Java-Versionen müssen durch Generika ergänzt werden, aber ich weiß nicht, wie das in Java geht. Aber Sie sollten in der Lage sein, ihnen anonyme innere Klassen zu übergeben, um die Funktoren bereitzustellen:
string[] names = getLotsOfNames();
string commaSeparatedNames = (string)reduce(names,
new IBinaryFunctor {
public object invoke(object arg1, object arg2)
{ return ((string)arg1) + ", " + ((string)arg2); }
}
Hoffentlich würden Generika die Abgüsse loswerden. Das typsichere Äquivalent in C # lautet:
string commaSeparatedNames = names.Aggregate((a, b) => a + ", " + b);
Warum ist das "cool"? Einfache Möglichkeiten, größere Berechnungen in kleinere Teile zu zerlegen, damit sie auf unterschiedliche Weise wieder zusammengesetzt werden können, sind immer cool. Google wendet diese Idee auf die Parallelisierung an, da sowohl Map als auch Reduce auf mehrere Computer verteilt werden können.
Die wichtigste Voraussetzung ist jedoch NICHT, dass Ihre Sprache Funktionen als Werte behandeln kann. Das kann jede OO-Sprache. Die eigentliche Voraussetzung für die Parallelisierung ist, dass die kleinen funcFunktionen, die Sie an die Zuordnung und Reduzierung übergeben, keinen Status verwenden oder aktualisieren dürfen. Sie müssen einen Wert zurückgeben, der nur von den an sie übergebenen Argumenten abhängt. Andernfalls werden die Ergebnisse völlig durcheinander gebracht, wenn Sie versuchen, das Ganze parallel auszuführen.