int fib(int n) {
 if(n == 0) return 1;
 if(n == 1) return 1;
 
 return fib(n - 2) + fib(n - 1);
}

int fib(0) {
 return 1;
}
int fib(1) {
 return 1;
}
int fib(int n) {
 return fib(n - 2) + fib(n - 1);
}

int f(int n < 10) { ... }
int f(int n) { ... }

Function makePowerFn(int power) {
 int powerFn(int base) {
 return pow(base, power);
 }


 return powerFn;
}


Function square = makePowerFn(2);
square(3); // returns 9

Function makeIncrementer() {
 int n = 0;


 int increment() {
 return ++n;
 }
}


Function inc1 = makeIncrementer();
Function inc2 = makeIncrementer();


inc1(); // returns 1;
inc1(); // returns 2;
inc1(); // returns 3;
inc2(); // returns 1;
inc2(); // returns 2;
inc2(); // returns 3;

class some_function_t {
 SymbolTable parentScope;
 
 // ...
}

Классный текст! Правда я так и не понял когда имеет смысл использовать ФП, а когда — нет. В статье очень много слов посвящено тому, как на ФП можно программировать в смысле ООП. А все преимущества описаны как возможный потенциал: возможность распараллеливание, возможность оптимизации без участия человека.

Хотелось бы конкретных примеров:
1. Распараллеливание — берем известный алгоритм, пишем программу на ФП и на ООП так, как нам удобно и сравниваем.
2. Оптимизация — берем известный алгоритм, пишем программу на ФП и на ООП так, как нам удобно и сравниваем.
Я так понимаю, что на ФП код должен получиться существенно короче и понятней, скорость примерно одинаковой, так?

Относительно ФП у меня сложилось впечатление, что его преимущества проявляются при решении для больших задач. Для решения простых кусочков большой проблемы код пишется на ООП, а вот чтобы составить из этих кусочков решение всей проблемы стОит применять ФП.

FP очень доставляет при работе с большим количеством данных. Data mining, etc.
Да и просто для релаксации иногда расчехляю тот же F#.

А как в этом случае с переполнением стека и нагрузкой на каналы передачи данных? Не становится ли она сильно избыточной?

Не понял что вы имеете ввиду под «нагрузка на каналы».

А насчет стека: есть катая замечательная вещь как «хвостовая рекурсия» — компилятор такие чудеса с ней творит )

Когда у нас переменные не изменяются, то фактически это означает, что память одноразовая. И если бы работаем со сложной структурой, о которой думаем как о чем-то неделимом, то мы не можем изменить какой-то ее кусочек, мы обязаны менять ее целиком. Т.е. заводить новую и туда копировать данные. Это не создает чрезмерную нагрузку на память?

Если мы работаем со сложной структурой, о которой думаем как о чем-то неделимом — то она должна быть неделимой вне зависимости от подхода.

А копирование памяти — операция довольно быстрая.

> Если мы работаем со сложной структурой, о которой думаем как о чем-то неделимом — то она должна быть неделимой вне зависимости от подхода.

Я неточно выразился. Возможно лучше s/неделимой/цельной/.

> А копирование памяти — операция довольно быстрая.

Все относительно. Но избыточного копирования больших объемов данных стараются избегать.

Впрочем, это не важно. Кажется я понял как сформулировать то, что меня напрягает в ФП: в ФП нет привычных структур данных, привычных в том смысле, что мы можем их схематично нарисовать на бумаге, и их хранение в памяти компьютера будет примерно таким же, как наша рукописная схема.

Пример: как в ФП будет хранится матрица целых чисел? Будет ли это непрерывный массив ячеек памяти длинных n^2? Если да, то на сколько эффективна будет работа с ним, когда нам потребуется изменять только несколько ячеек? Если нет, то насколько эффективна будет работа с ним, когда нам потребуется работать со всеми ячейками?

Возможно это покажется некорректным, когда в для реализации одних алгоритмов мы хотим понимать структуру данных как нечто целое и неделимое, а для других алгоритмов как — нечто составное. Но, наверное, в этом и состоит основная задача разработки удобных структур данных — чтобы они были удобные и допускали разные уровни абстракции.