1. Чистые функции:

• Определение: Функция считается чистой, если она свободна от побочных эффектов и всегда возвращает идентичный результат при одинаковых входных данных. Это подразумевает следующие характеристики чистых функций:
  • Отсутствие изменений данных за пределами своего локального контекста (например, глобальных переменных).
  • Отсутствие операций ввода-вывода, таких как чтение из файла или вывод на экран.
  • Результат зависит исключительно от переданных аргументов.
• Примеры:
  • Чистая функция: inc(x) в Python и (inc x) в Scheme. Обе функции просто увеличивают переданное число на 1, не вызывая никаких побочных эффектов.
  • "Грязная" функция: randInc(x) в Python and (rand-inc x) в Scheme. Эти функции используют генератор случайных чисел, поэтому их результат зависит не только от аргумента x, но и от текущего состояния генератора.
• Преимущества: Чистые функции легче тестировать и отлаживать, поскольку их поведение предсказуемо. Более того, они способствуют созданию модульного и многократно используемого кода.

2. Функции первого класса и высшего порядка:

• Функции первого класса: В языках, поддерживающих функции первого класса, функции могут рассматриваться как обычные значения. Это означает, что функции можно:
  • Передавать в качестве аргументов другим функциям.
  • Возвращать из функций.
  • Сохранять в переменных и структурах данных.
  • Создавать во время выполнения.
• Функции высшего порядка: Функция высшего порядка - это функция, которая принимает другую функцию в качестве аргумента или возвращает функцию в качестве результата.
• Примеры:
  • В Python:

# Определение функции, которая прибавляет единицу
# к каждому элементу списка
def inc(L):
  return [x + 1 for x in L]

# Функция, которая принимает функцию в качестве
# аргумента и возвращает другую функцию
# в качестве результата
def changeList(f, L):
  return f(L)

# changeList(f, L) = f(L)
>>> changeList(inc,)

# Хранение функции в переменной
>>> c = changeList
>>> c(inc,)

# Хранение функций в структурах данных
# предоставляемых языком. В данном случае, хранение
# анонимных функций в словаре.
hashIncDec = {
  'inc': lambda x: x + 1,
  'dec': lambda x: x - 1
}
>>> hashIncDec['inc'](5)
6
>>> hashIncDec['dec'](5)
4

В Scheme:

;; Определение функции, которая прибавляет единицу
;; к каждому элементу списка
(define (inc-list L)
  (map 1+ L))

;; Функция, которая принимает функцию в качестве
;; аргумента и возвращает другую функцию
;; в качестве результата
(define (change-list f L)
  (f L))

scheme@(guile-user)> (change-list inc-list '(1 2 3))
$1 = (2 3 4)

;; Хранение функции в переменной
(define c change-list)
scheme@(guile-user)> (c inc-list '(1 2 3))
$2 = (2 3 4)

;; Хранение функций в структурах данных
;; предоставляемых языком. В данном случае, хранение
;; анонимных функций в хеш-таблице.
(define hash-inc-dec (make-hash-table))
(hash-set! hash-inc-dec 'inc (lambda (x) (+ x 1) ))
(hash-set! hash-inc-dec 'dec (lambda (x) (- x 1) ))

scheme@(guile-user)> ((hash-ref hash-inc-dec 'inc) 5)
$3 = 6
scheme@(guile-user)> ((hash-ref hash-inc-dec 'dec) 5)
$4 = 4

В этих примерах функции inc, inc-list, changeList и change-list демонстрируют принципы функций первого класса и высшего порядка. Они передаются как аргументы, возвращаются как результаты и сохраняются в переменных.

3. Замыкания:

• Определение: Замыкание - это функция, которая "запоминает" значения переменных из своего лексического окружения (области видимости) даже после завершения внешней функции.
• Примеры:
  • Python:

# Замыкание
def sum(x):
  def sumXY(y):
    return x + y
  return sumXY

>>> s = sum(10)
>>> result = s(5)
>>> result
15

*   Scheme:

;; Замыкание
(define (sum x)
  (lambda (y)
    (+ x y)))

(define sum-x-y (sum 10))

scheme@(guile-user)> (sum-x-y 5)
$1 = 15

• В этих примерах функции sum и (sum x) создают замыкания. Внутренняя функция sumXY или (lambda (y) (+ x y)) имеет доступ к переменной x внешней функции даже после завершения sum.

4. Каррирование: