Ако сте посещавали лекции във ФМИ, несъмнено знаете че съществуват и по-екзотични начини за писане на код от Java и C#. Един от тях е функционалното програмиране. Характерно за него са „функции от по-висок ред“ – такива чиито аргументи или връщани стойности също са функции. Един от първите и най-известни езици за функционално програмиране е LISP. Той предлага някои много елегантни решения на доста проблеми, но едва ли ще се сблъскате с него в днешни дни, освен ако не учите във ФМИ или не пишете макроси за emacs. Въпреки, че едва ли някой пише цели приложения на LISP в днешни дни, някои от идеите на функционалното програмирне са съвсем приложими в „модерните“ езици… Не става въпрос просто за функции от по-висок ред – указатели към функции има още в C. Там най-често те се ползват за callback. В обектно-ориентираните езици тези неща стават по-добре с предаването на обект, който имплементира определен интерфейс/наследява определен клас, което се поддържа доста по-лесно. Готиното нещо в LISP са closure-ите – анонимни функции, които имат достъп до променливите на блока, в който са дефинирани. Тази простичка идея прави някои неща много по-лесни за изразяване. Едно от тях е работата със списъци. Например:

people е масив, а map е негов метод, който взема анонимна функция. Самата тя се дефинира с { |person| person.split(' ')[1] } – взема един аргумент perosn, разцепва го на думи и връща втората. map работи така – изпълнява приетата функция за всеки елемент от масива на който е извикана и връща нов масив, който съдържа върнатите стойности.

Има логика, нали? Кода се чете лесно – „map-ни всеки елемент от people със person.split(' ')[1]„. Функцията map идва от LISP. Друга такава е filter (в ruby се казва find_all), която връща нов списък, съдържащ тези елементи, за които подадената функция върне true. Ако искаме да изведем само тези фамилии, които имат шест символа, може да се направи така:

Традиционния вариант изглежда така: :ruby: result = [] for person in people do family_name = p.split(‘ ‘)[1] if family_name.length() == 6 do result << family_name end end

Предимствата? Първия вариант е по-кратък, по-прост и съответно се чете много по-лесно. Също така, е по-близко до това което искате да направите – чете се като „трансформирайте имената до фамилии и оставете шестбуквените“, за разлика от втория, който звучи по-скоро като „създай нов списък, обходи иметата, извади фамилии, провери дали фамилиите са шестбуквени и ако да, запиши ги в новосъздадения списък“. Цялата идея за предаване на функция, която да се изпълни за всеки елемент е много блага и лесна за прочит.

Освен работата със списъци, има още един случай в които closure-ите са ужасно полезни – когато имате някакъв стандартен try/catch блок, който искате да презползвате. Класическия пример за това е работата в файлове:

Когато взема блок код, функцията open работи по следния начин – отваря съответния файл и изпълнява кода, предавайки отворения файл като аргумент (в случая като my_file). След изхода му, бил той нормален или с изключение, open затваря файл. Така няма да забравите да освободите ресурса, а и кода отново е по-близо до замисъла ви – „направи с този файл това“, вместо „отвори файла, опитай да направиш това, finally затвори файла“. Други примери за употреба на такива блокове са връзки към бази данни и транзакции – вярвам, че няма нужда да давам пример.

Има редица други случаи, в които анонимните функции са елегантно решение, но това са двата pattern-на които най-често срещам. До каква степен се поддържат те в съвременните езици? Perl си има code references и много от нещата от CPAN ги ползват по такъв начин – например DBIx::Class за транзакции или вградените функции map, sort и grep. Ruby практически е наполовина език за функционално програмиране – цялата стандартна библиотека използва корутини много активно. В Python механизма не е чак толкова мощен – има няколко различни feature-а, които заедно покриват по-голяма част от полезните инструменти на функционалното програмиране, но липсват цялостни анонимни функци. Естествено, в PHP положението е трагично – там трябва да предавате стрингове с имена на функции, но и начина за създаване е трагичен. Closure-и няма, защото и без това scope-овете са два – локален и глобален. Java-та има нещо подобно с анонимни вътрешни класове, макар че за следващата версия може да доживеем да ги видим в по-приличен вид. В C# пък има, using израз, който е идеален за try/catch блокове. Чувам от някои хора, че Mircosoft били наели много от разработчиците на haskell, което ме кара да се надявам, че ще видим доста мощен функционален апарат в следващия .NET.

Според мен функционалното елементи могат много да допринесат в съвременното програмиране. Те ни дават по-малко код, който се чете по-лесно и е по-близо до идеята, с която е написан. Разбира се, изисква малко да разчупите начина си на мислене, за да ви хрумне да замените:

със

И все пак, това което получавате в замяна си заслужава. Горещо ви препоръчвам да разгледате функционалните способности на езика, който използвате. Дори да ви изглежда малко странно на пръв поглед, вярвам че въобще няма да се замисляте веднъж като му хванете цаката.