Map es una función que aplica otra función a todos los elementos de una lista, para producir otra lista con todos los valores devueltos. (Otra forma de decir "aplicar f a x" es "llamar f, pasándola x". Por eso, a veces suena mejor decir "aplicar" en lugar de "llamar").
Así es como el mapa probablemente está escrito en C # (se llama Selecty está en la biblioteca estándar):
public static IEnumerable<R> Select<T, R>(this IEnumerable<T> list, Func<T, R> func)
{
foreach (T item in list)
yield return func(item);
}
Como eres un tipo de Java, y a Joel Spolsky le gusta contar MENTIRAS GROSSLY INJUSTAS sobre lo malo que es Java (en realidad, él no está mintiendo, es una mierda, pero estoy tratando de conquistarte), aquí está mi intento muy rudo de una versión de Java (no tengo un compilador de Java, y recuerdo vagamente la versión 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;
}
Estoy seguro de que esto se puede mejorar en un millón de formas. Pero es la idea básica.
Reducir es una función que convierte todos los elementos de una lista en un solo valor. Para hacer esto, necesita tener otra función funcque convierta dos elementos en un solo valor. Funcionaría dándole los dos primeros elementos a func. Luego, el resultado de eso junto con el tercer elemento. Luego, el resultado de eso con el cuarto elemento, y así sucesivamente hasta que todos los elementos hayan desaparecido y nos quedemos con un valor.
En C # se llama a reduce Aggregatey vuelve a estar en la biblioteca estándar. Pasaré directamente a una versión de 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;
}
Estas versiones de Java necesitan que se les agreguen genéricos, pero no sé cómo hacerlo en Java. Pero debería poder pasarles clases internas anónimas para proporcionar los functores:
string[] names = getLotsOfNames();
string commaSeparatedNames = (string)reduce(names,
new IBinaryFunctor {
public object invoke(object arg1, object arg2)
{ return ((string)arg1) + ", " + ((string)arg2); }
}
Con suerte, los genéricos eliminarían los yesos. El equivalente de seguridad de tipos en C # es:
string commaSeparatedNames = names.Aggregate((a, b) => a + ", " + b);
¿Por qué es esto "genial"? Las formas sencillas de dividir cálculos más grandes en partes más pequeñas, para que puedan volver a juntarse de diferentes maneras, siempre son geniales. La forma en que Google aplica esta idea es mediante la paralelización, porque tanto el mapa como la reducción se pueden compartir en varias computadoras.
Pero el requisito clave NO es que su idioma pueda tratar las funciones como valores. Cualquier idioma de OO puede hacer eso. El requisito real para la paralelización es que las pequeñas funcfunciones que pase a mapear y reducir no deben usar ni actualizar ningún estado. Deben devolver un valor que dependa solo de los argumentos que se les pasen. De lo contrario, los resultados se estropearán por completo cuando intente ejecutar todo en paralelo.