Кратко про FP в Julia

В отличие от императивного подхода, где выражается последовательность операций, функциональное программирование (FP) сосредотачивается на "что" и "как" должно быть вычислено, а не на "когда". Это приводит к более чистому, модульному и легко тестируемому коду.

Juliа поддерживает анонимные функции, замыкания, и имеет систему типов, которая позволяет писать высокооптимизированный код без потери читаемости и удобства.

Основы

Чистые функции – это база. Они не имеют побочных эффектов и возвращают один и тот же результат при одинаковых входных данных:

function add(a, b)
    return a + b
end

Функция add является чистой, потому что она всегда возвращает один и тот же результат для одних и тех же значений a и b, и не имеет побочных эффектов

Функции высшего порядка принимают другие функции в качестве аргументов или возвращают их как результат. Это позволяет создавать абстракции высокого уровня и различные шаблоны программирования:

function apply_twice(f, x)
    return f(f(x))
end

result = apply_twice(x -> x * 2, 5)  # 20

apply_twice принимает функцию f и применяет её дважды к значению x. Используем анонимную функцию (x -> x * 2), чтобы удвоить значение.

Лямбда-функции (или анон.функции) позволяют создавать компактные выражения для коротких функций без необходимости их именования. Замыкания же позволяют использовать переменные из внешнего контекста:

x = 10
multiplier = y -> x * y  # замыкание использующее переменную x из внешнего контекста

println(multiplier(5))  # 50

multiplier умножает свой аргумент на значение переменной x, определённой вне функции.

Неизменяемость данных и управление состоянием

В Julia базовые типы данных являются неизменяемыми. Т.е, создав экземпляр такого типа, нельзя изменить его содержимое. Попытка это сделать приведёт к созданию нового экземпляра, а не изменению существующего.

x = 10
x = 20  # создаётся новый объект, а не изменяется существующий

Julia предоставляет ключевое слово struct для определения неизменяемых пользовательских типов. После создания экземпляра такого типа, его поля не могут быть изменены:

struct Point
  x::Int
  y::Int
end

p = Point(1, 2)
# p.x = 3  # вызовет ошибку, так как структура Point неизменяема

Для создания изменяемых структур используется слово mutable struct. Однако в контексте FP предпочтение отдаётся неизменяемым структурам

Как можно использовать неизменяемость на практике в Julia для создания функционалки:

# неизменяемая структура данных
struct ImmutableVector
  data::Vector{Int}
end

# функция, создающая новый ImmutableVector с добавленным элементом
function add_element(ivec::ImmutableVector, element::Int)
  new_data = copy(ivec.data)
  push!(new_data, element)
  return ImmutableVector(new_data)
end

ivec = ImmutableVector([1, 2, 3])
ivec_new = add_element(ivec, 4)

Вместо изменения существующего экземпляра ImmutableVector, функция add_element создаёт новый экземпляр с изменённым состоянием.

Монады и функторы

Функтор – это тип данных, который можно отобразить с помощью функции, применённой к каждому его элементу. Если пошире, это любой тип, для которого можно определить функцию map. В Julia массивы являются примером функторов, поскольку к ним можно применить функцию map:

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(x -> x^2, numbers)
println(squared_numbers)  # Выведет [1, 4, 9, 16, 25]

map применяет функцию к каждому элементу массива numbers, возвращая новый массив squared_numbers, где каждый элемент возведён в квадрат.

Монады – это более сложная концепция, чем функторы. Они позволяют последовательно выполнять вычисления, где каждое следующее вычисление зависит от результатов предыдущего. Монады также помогают обрабатывать побочные эффекты и ошибки в чисто функциональном стиле.

Хотя Julia не имеет встроенной поддержки монад в стандартной библиотеке, можно реализовать их самостоятельно:

struct Maybe{T}
  value::Union{Nothing, T}
end

# функция создания "успешного" значения
success(x) = Maybe(x)

# функция для создания "неудачного" значения
failure() = Maybe{Nothing}(nothing)

# bind для монады Maybe
function bind(m::Maybe, f)
  if isnothing(m.value)
    return failure()
  else
    return f(m.value)
  end
end

# пример использования
safe_divide = x -> x != 0 ? success(1/x) : failure()
result = bind(success(2), safe_divide)
println(result)  # Maybe(0.5)

Монаа Maybe может содержать либо значение, либо nothing, если произошла ошибка. bind позволяет применить функцию к значению внутри Maybe, только если это значение не nothing.

Рекурсия и оптимизация хвостовой рекурсии

Рекурсия позволяет описывать решения для сложных задач более естественным и выразительным способом, часто с меньшим количеством кода. Без должной осторожности рекурсия может привести к переполнению стека вызовов.

Простой рекурсивный пример – функция для вычисления факториала числа:

function factorial(n)
    if n == 0
        return 1
    else
        return n * factorial(n - 1)
    end
end

println(factorial(5))  # 120

При больших значениях n такой подход может привести к переполнению стека.

Хвостовая рекурсия – это особый случай рекурсии, при котором рекурсивный вызов является последней операцией, выполняемой функцией.

В джулиа есть поддержка оптимизации хвостовой рекурсии, но она может быть не так очевидна:

function factorial_tail(n, acc=1)
    if n == 0
        return acc
    else
        return factorial_tail(n - 1, n * acc)
    end
end

println(factorial_tail(5))  # 120

acc используется для накопления результата, и рекурсивный вызов является последней операцией функции

Julia не всегда автоматически оптимизирует хвостовую рекурсию. Для этого можно использовать макрос @tailrec из пакета TailRecursion.jl для явного указания на необходимость такой оптимизации:

using TailRecursion

@tailrec function factorial_tail_opt(n, acc=1)
    if n == 0
        return acc
    else
        return factorial_tail_opt(n - 1, n * acc)
    end
end

println(factorial_tail_opt(5))  # 120

Как юзать fp для аналитики

Представим, что есть данные о температуре за несколько месяцев, и нужно вычислить скользящее среднее для упрощения визуализации трендов. В FP можно решить эту задачу, используя функции высшего порядка и неизменяемые структуры данных:

# к примеру, есть такой массив температур
temperatures = [3.5, 4.1, 5.6, 7.2, 9.1, 12.3, 14.6, 14.9, 12.8, 9.7, 6.5, 4.3]

# функция для вычисления скользящего среднего
function moving_average(data, window_size)
    len = length(data)
    result = []

    for i in 1:(len - window_size + 1)
        window = data[i:(i + window_size - 1)]
        push!(result, sum(window) / window_size)
    end

    return result
end

# вчисляем скользящее среднее с окном в 3 месяца
average_temperatures = moving_average(temperatures, 3)

Ну и к примеру, есть данные о пациентах нужно отфильтровать по возрасту, а затем преобразовать эти данные для дальнейшего анализа:

# массив словарей, представляющих данные о пациентах
patients = [
    Dict("name" => "Alice", "age" => 30),
    Dict("name" => "Bob", "age" => 45),
    Dict("name" => "Charlie", "age" => 25)
]

# функция для фильтрации пациентов по возрасту
function filter_patients(data, age_threshold)
    filter(patient -> patient["age"] > age_threshold, data)
end

# функция для преобразования данных пациентов
function transform_patients(data)
    map(patient -> Dict("patient_name" => patient["name"], "patient_age" => patient["age"]), data)
end

# фильтрация и трансформация
filtered_patients = filter_patients(patients, 30)
transformed_patients = transform_patients(filtered_patients)

---

Больше практических инструментов, вы можете изучить в рамках онлайн-курсов от практикующих экспертов. В каталоге курсов OTUS все заинтересованные смогут найти подходящее направление, а в календаре мероприятий зарегистрироваться на предложенные бесплатные вебинары.