TL; DR
Programowanie funkcjonalne dotyczy zamknięć i ich aplikacji. O ile ktoś nie jest w stanie pokazać biblioteki zamykającej zejście dla C, zapomnij o użyciu C do nauki programowania funkcjonalnego.
Co to jest programowanie funkcjonalne?
Kardynalną koncepcją programowania funkcjonalnego jest pojęcie zamknięć, które z grubsza ujmują funkcję wraz z powiązaniami zmiennych. Oprócz powszechnego użycia zamknięć, istnieje kilka innych charakterystycznych cech w programowaniu funkcjonalnym, takich jak użycie funkcji rekurencyjnych i niezmiennych wartości (obie grają dobrze razem). Te cechy są bardziej kwestią kulturową niż cokolwiek innego i nie ma technicznych przeszkód, aby używać ich w praktycznie dowolnym języku, dlatego w mojej odpowiedzi skupiam się na zamknięciach: nie każdy język pozwala na łatwe tworzenie zamknięć.
Trzy ilustracje przydatności zamknięć
Typowym zastosowaniem zamknięć jest wdrożenie mechanizmów prywatności. Na przykład kod JavaScript - w przykładach wybrałem Javascript, ponieważ jest to język funkcjonalny o tak zwanej „składni podobnej do C”, a twoje pytanie sugeruje, że znasz C:
create_counter = function()
{
var x = 0;
var counter = function()
{
++x;
return x;
};
return counter;
}
Potem z
a = create_counter();
b = create_counter();
mamy dwie funkcje ai bliczenie rozłącznych kolekcji. Punktem przykładu jest to, że zmienne xsą przechwytywane przez zamknięcie definiujące counterzamknięcie i za każdym razem, gdy jest nowe counterzamknięcie is instantiated by the function, it gets its fresh own idea of whatx`.
Innym typowym zastosowaniem zamknięć jest definicja częściowego zastosowania funkcji. Załóżmy, że mamy funkcję raportowania podobną do syslogimplementacji funkcji
var log = function(priority, message) {
…
};
gdzie argumenty priorityi messageoczekuje się być ciągi, pierwszy będąc jednym "debug", "info"i tak dalej. Możemy zdefiniować fabrykę logów w następujący sposób:
var logWithPriority = function(priority) {
return function(message) {
log(priority, message);
};
};
i użyj go do zdefiniowania specjalistycznych wersji naszego narzędzia do rejestrowania:
var debug = logWithPriority("debug");
var info = logWithPriority("info");
…
Jest to bardzo przydatne, ponieważ zamiast pisać takie podatne na błędy forpętle
for(i = 0; i < journal.length; ++i) {
log("info", journal[i]);
}
możemy napisać czystsze, krótsze i znacznie prostsze (nie ma i, to jest znacznie lepsze):
journal.forEach(logWithPriority("info"));
Trzecim ważnym obszarem zastosowania zamknięć jest wdrożenie leniwej oceny - należy pamiętać, że specjalne wsparcie językowe może zapewnić lepszą implementację.
Leniwa funkcja zamiast wykonywania prostych obliczeń zwraca zamknięcie, które można wywołać (lub „wymusić” w żargonie lenistwa) w celu wykonania pytania. Motywacją do tego jest oddzielenie przygotowywania obliczeń i wykonywania obliczeń. Praktycznym tego przykładem jest kompilacja wyrażeń regularnych: jeśli program skompiluje wiele wyrażeń regularnych w czasie uruchamiania, uruchomienie programu będzie wymagało dużo czasu. Jeśli zamiast tego leniwie skompilujemy wyrażenia regularne i wymuszymy je tak, jak potrzebujemy, nasz program może się szybko uruchomić. Oczywiście, wyrażenia regularne można tutaj zastąpić dowolną strukturą wymagającą znacznego czasu inicjalizacji.
Oto jak wdrożyć leniwą ocenę z zamknięciami. Rozważ klasyczną implementację funkcji arrayMax zwracającą maksimum w tablicy:
function arrayMax(array) {
return array.reduce(function(a, b) {
return Math.min(a, b);
};
}
Leniwym wariantem byłoby:
function arrayMax(array) {
var memo = null;
function actuallyCompute() {
if(memo === null) {
memo = array.reduce(function(a, b) {
return Math.min(a, b);
});
}
return memo;
}
return actuallyCompute;
}
Zwrócona wartość to zamknięcie, którego można użyć do obliczenia wartości lub odzyskania jej innym razem, jeśli została już obliczona.
Dzięki tym trzem przykładom powinniśmy być pewni, że zamknięcia i ich aplikacje są podstawą programowania funkcjonalnego.
Wniosek
Nauka programowania funkcjonalnego oznacza naukę programowania z zamknięciami. W związku z tym podczas wyszukiwania języka do programowania funkcjonalnego należy wziąć pod uwagę języki umożliwiające łatwą manipulację zamknięciami, a zwłaszcza częściowe zastosowanie funkcji. I odwrotnie, języki, w których nie można łatwo manipulować zamknięciami, byłyby złym wyborem.