Какие использовал функциональные языки?

Какие использовал функциональные языки?

Функциональное программирование (FP) — это парадигма, которая акцентирует внимание на использовании чистых функций и иммутабельных данных. За 10+ лет разработки я работал с несколькими функциональными языками и применял FP-принципы в своих проектах.

Основной опыт: Lisp / Scheme

Изучение

На ранних этапах моей карьеры я изучал Lisp и Scheme — классические функциональные языки.

; Простая функция на Scheme
(define (factorial n)
  (if (= n 0)
      1
      (* n (factorial (- n 1)))))

(factorial 5) ; => 120

; map, filter, reduce
(map (lambda (x) (* x 2)) '(1 2 3 4 5))
; => (2 4 6 8 10)

(filter (lambda (x) (> x 2)) '(1 2 3 4 5))
; => (3 4 5)

(fold-left + 0 '(1 2 3 4 5))
; => 15

Что выучил:

• Рекурсия как основной способ итерации
• Функции первого класса (higher-order functions)
• Замыкания и лексический scope
• S-выражения (everything is a list)

Haskell

Экспериментирование

Я экспериментировал с Haskell — строго типизированным функциональным языком.

-- Функция квадрата
square :: Int -> Int
square x = x * x

-- Функция порядка высшего
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)

-- List comprehension
allSquares = [x * x | x <- [1..10]]
-- => [1,4,9,16,25,36,49,64,81,100]

-- Pattern matching
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

-- Функции с типовыми ограничениями
getMax :: (Ord a) => a -> a -> a
getMax x y = if x > y then x else y

Что выучил:

• Сильная статическая типизация с type inference
• Pattern matching для деконструкции данных
• Immutability по умолчанию
• Функция map, filter, fold
• Монады (очень полезно для контроля эффектов)

Clojure

Production опыт

Я использовал Clojure (функциональный Lisp на JVM) в реальных проектах.

; Синтаксис
(def users [{:id 1 :name "John" :age 30}
            {:id 2 :name "Jane" :age 25}])

; Функции
(defn get-adult-users [users]
  (filter #(>= (:age %) 18) users))

; Thread macro для читаемости
(-> [1 2 3 4 5]
    (map inc)
    (filter even?)
    (reduce +))
; => 8

; Immutable structures
(def person {:name "John" :age 30})
(assoc person :age 31) ; Создает новый объект, не меняет исходный

; Async programming
(go
  (let [result (<! (fetch-user))]
    (println result)))

Что выучил:

• Конкурентность через go-блоки
• Immutable data structures
• Powerful metaprogramming
• Java interop для использования JVM библиотек

Functional Programming в JavaScript/Node.js

Применение FP в реальных проектах

Хотя JavaScript не чисто функциональный язык, я часто применяю FP-принципы в Node.js коде.

// Чистые функции (pure functions)
const add = (a, b) => a + b;  // Всегда возвращает одинаковый результат
const multiply = (a, b) => a * b;

// Композиция функций
const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

const addTwo = x => x + 2;
const multiplyByThree = x => x * 3;
const subtractOne = x => x - 1;

const pipeline = compose(subtractOne, multiplyByThree, addTwo);

pipeline(5);
// addTwo(5) = 7
// multiplyByThree(7) = 21
// subtractOne(21) = 20

// Higher-order functions
const map = (fn, arr) => arr.map(fn);
const filter = (predicate, arr) => arr.filter(predicate);
const reduce = (fn, initial, arr) => arr.reduce(fn, initial);

// Currying
const curry = (fn) => {
  const arity = fn.length;
  return function $curry(...args) {
    if (args.length < arity) {
      return $curry.bind(null, ...args);
    }
    return fn.call(null, ...args);
  };
};

const add = curry((a, b, c) => a + b + c);
const add5 = add(5);        // Partial application
const add5_3 = add5(3);     // Still waiting
const result = add5_3(2);   // => 10

// Immutability
const user = { name: 'John', age: 30 };
const newUser = { ...user, age: 31 }; // Spread operator

const users = [1, 2, 3];
const newUsers = [...users, 4]; // Не меняет исходный

// Functional reactive programming (RxJS)
from([1, 2, 3, 4, 5])
  .pipe(
    map(x => x * 2),
    filter(x => x > 5),
    reduce((acc, x) => acc + x, 0)
  )
  .subscribe(result => console.log(result)); // 18

Elixir

Исследование

Я экспериментировал с Elixir (функциональный язык на BEAM VM).

# Функции
def factorial(n) when n <= 1, do: 1
def factorial(n), do: n * factorial(n - 1)

# Pattern matching
def greet({:ok, message}), do: "Success: #{message}"
def greet({:error, reason}), do: "Error: #{reason}"

# Pipe operator
def process(user) do
  user
  |> String.downcase()
  |> String.trim()
  |> String.length()
end

# Immutable lists
list = [1, 2, 3]
new_list = [0 | list]  # => [0, 1, 2, 3]

# Concurrency (very powerful)
spawn(fn ->
  receive do
    {:message, msg} -> IO.puts(msg)
  end
end)

Функциональные концепции, которые я использую ежедневно

1. Pure Functions (Чистые функции)

// ✅ Чистая функция
const calculate = (a, b) => a + b;

// ❌ Нечистая функция (зависит от внешнего состояния)
let counter = 0;
const increment = () => ++counter;  // Side effect!

2. Immutability

// ❌ Мутация (опасно в async коде)
const user = { name: 'John', age: 30 };
user.age = 31;  // Меняет оригинальный объект

// ✅ Иммутабельность
const newUser = { ...user, age: 31 };  // Новый объект

3. Function Composition

const users = [
  { id: 1, name: 'John', age: 30 },
  { id: 2, name: 'Jane', age: 25 },
  { id: 3, name: 'Bob', age: 35 }
];

// Composable pipeline
const getAdultNames = (users) =>
  users
    .filter(u => u.age >= 18)
    .map(u => u.name)
    .sort();

getAdultNames(users); // ['Bob', 'Jane', 'John']

4. Higher-order Functions

// Функция, которая возвращает функцию
const memoize = (fn) => {
  const cache = {};
  return (arg) => {
    if (arg in cache) return cache[arg];
    const result = fn(arg);
    cache[arg] = result;
    return result;
  };
};

const expensiveCalc = memoize((n) => {
  // Дорогостоящее вычисление
  return n * n;
});

expensiveCalc(5); // Вычисляет
expensiveCalc(5); // Возвращает из кэша

Как FP улучшает код

Тестируемость

// Функциональный подход (легко тестировать)
const getUserEmail = (user) => user.email;
const isAdult = (user) => user.age >= 18;
const getAdultEmails = (users) => users.filter(isAdult).map(getUserEmail);

test('getAdultEmails returns only adults', () => {
  const users = [{ age: 17 }, { age: 25 }];
  expect(getAdultEmails(users)).toEqual([users[1].email]);
});

Отладка

// С логированием в pipeline
const log = (label) => (value) => {
  console.log(label, value);
  return value;
};

users
  .filter(isAdult)
  .pipe(log('adults'))           // [ adult1, adult2 ]
  .map(getUserEmail)
  .pipe(log('emails'))           // [ 'john@example.com', 'jane@example.com' ]
  .filter(isValid)
  .pipe(log('valid emails'));    // [ 'john@example.com' ]

Итоги

Мой опыт с функциональными языками:

1. Lisp/Scheme — фундаментальное понимание FP
2. Haskell — типизированный FP
3. Clojure — production FP на JVM
4. JavaScript — применение FP-принципов в реальных проектах
5. Elixir — конкурентный FP

Функциональное программирование дает:

• Более читаемый и поддерживаемый код
• Легче тестировать
• Меньше ошибок (особенно в async коде)
• Лучше масштабируется
• Проще отлаживать

Я убежден: даже в imperative языках (JavaScript, Python) следует применять FP-принципы для написания качественного кода. Это не противоречиво, это дополняет друг друга.