Harita, bir listedeki tüm öğelere başka bir işlevi uygulayan, tüm dönüş değerleri ile başka bir liste oluşturan bir işlevdir. ("F'yi x'e uygula" demenin başka bir yolu da "f'yi çağır, x'i geç" tir. Bu nedenle bazen "ara" yerine "uygula" demek daha hoş gelebilir.)
Harita muhtemelen C # ile nasıl yazılır (denir Selectve standart kitaplıkta bulunur):
public static IEnumerable<R> Select<T, R>(this IEnumerable<T> list, Func<T, R> func)
{
foreach (T item in list)
yield return func(item);
}
Sen bir Java adamı olduğun için ve Joel Spolsky BÜYÜK YALANLARA Java'nın ne kadar berbat olduğunu söylemeyi seviyor (aslında yalan söylemiyor, berbat, ama seni kazanmaya çalışıyorum), işte benim çok kaba girişimim bir Java sürümü (Java derleyicim yok ve Java sürüm 1.1'i belli belirsiz hatırlıyorum!):
// 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;
}
Eminim bu, milyonlarca şekilde geliştirilebilir. Ama temel fikir bu.
Azaltma, bir listedeki tüm öğeleri tek bir değere dönüştüren bir işlevdir. Bunu yapmak için, funciki öğeyi tek bir değere dönüştüren başka bir işlevin verilmesi gerekir . İlk iki maddeyi vererek işe yarayacaktır func. Sonra üçüncü maddeyle birlikte bunun sonucu. Sonra bunun sonucu dördüncü maddeyle birlikte ve böylece tüm öğeler gidene ve tek bir değerle kalana kadar devam edecek.
C # 'da küçültme çağrılır Aggregateve yine standart kitaplıkta bulunur. Doğrudan bir Java sürümüne geçeceğim:
// 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;
}
Bu Java sürümlerinin eklenmesi gereken jenerikler, ancak bunu Java'da nasıl yapacağımı bilmiyorum. Ancak, functors sağlamak için onlara anonim iç sınıfları geçirebilmelisiniz:
string[] names = getLotsOfNames();
string commaSeparatedNames = (string)reduce(names,
new IBinaryFunctor {
public object invoke(object arg1, object arg2)
{ return ((string)arg1) + ", " + ((string)arg2); }
}
Umarım jenerikler dökümlerden kurtulur. C # 'daki tip güvenli eşdeğeri:
string commaSeparatedNames = names.Aggregate((a, b) => a + ", " + b);
Bu neden "harika"? Büyük hesaplamaları daha küçük parçalara ayırmanın basit yolları, böylece farklı şekillerde bir araya getirilebilir, her zaman harikadır. Google'ın bu fikri uygulama şekli paralelleştirmedir çünkü hem harita hem de küçültme birkaç bilgisayar üzerinden paylaşılabilir.
Ancak temel gereksinim, dilinizin işlevleri değerler olarak ele alabilmesi DEĞİLDİR. Herhangi bir OO dili bunu yapabilir. Paralelleştirme için gerçek gereksinim, eşlemeye funcgeçirdiğiniz ve azalttığınız küçük işlevlerin herhangi bir durumu kullanmaması veya güncellememesidir. Yalnızca kendilerine iletilen argümanlara bağlı bir değer döndürmeleri gerekir. Aksi takdirde, her şeyi paralel olarak çalıştırmaya çalıştığınızda sonuçlar tamamen alt üst olur.