Модуль Fun

module Fun: sig .. end

Комбинаторы

val id : 'a -> 'a

val const : 'a -> 'b -> 'a

val compose : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c

val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c

val negate : ('a -> bool) -> 'a -> bool

Обработка исключений

val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a

exception Finally_raised of exn

Примеры

Комбинаторы

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

id

List.init с самим индексом

  # List.init 3 Fun.id;;
  - : int list = [0; 1; 2]

Использование List.filter_map для int option list с целью отфильтровать элементы None

  # List.filter_map Fun.id [None; Some 2; Some 3; None; Some 5];;
  - : int list = [2; 3; 5]

Условная передача функций типа foo -> foo или передача их в качестве аргументов — ещё одна область, где может быть полезен id. Рассмотрим простую функцию журналирования, которая выводит строку, но позволяет пользователю предварительно отформатировать её перед выводом, например, добавить метку времени.

  let log ?(preformat : string -> string = Fun.id) message =
    print_endline (preformat message)

Если можно накапливать замыкания, id часто используется в качестве базового случая, ничего не делающего. Рассмотрим функцию, которая объединяет список унарных функций в цепочку:

  let rec chain = function
    | [] -> Fun.id
    | f :: fs -> fun x -> f (chain fs x)

const

List.init список нулей

  # List.init 3 (Fun.const 0);;
  - : int list = [0; 0; 0]

Предикат, допускающий все значения: его можно передать любой функции фильтрации, например List.filter, чтобы отключить фильтрацию и получить все значения

  # List.filter (Fun.const true) [1; 2; 3];;
  - : int list = [1; 2; 3]

Обратите внимание, что применение const (...) вычисляет выражение (...) один раз и возвращает функцию, в которой сохранён только результат этого вычисления. Чтобы показать это, рассмотрим случай, когда (...) — вызов Random.bool():

List.init n (Fun.const (Random.bool())) для любого n > 0 будет иметь ровно два возможных результата:

• [true; true; ...; true]
• [false; false; ...; false]

тогда как List.init n (fun _ -> Random.bool()) будет иметь 2ⁿ возможных результатов, поскольку случайное значение выбирается для каждого элемента.

В качестве примера из реальной практики можно рассмотреть String.spellcheck с постоянным максимальным расстоянием, равным 2, вместо максимального расстояния, изменяющегося по умолчанию.

  let spellcheck known_words word =
    let dict_iter yield = List.iter yield known_words in
    String.spellcheck ~max_dist:(Fun.const 2) dict_iter word

flip

Использование flip для обращения компаратора, переданного в List.sort, что позволяет сортировать в обратном порядке

  # List.sort (Fun.flip Int.compare) [5; 3; 9; 0; 1; 6; 8];;
  - : int list = [9; 8; 6; 5; 3; 1; 0]

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

  # List.fold_left (Fun.flip List.cons) [] [1; 2; 3];;
  - : int list = [3; 2; 1]

Интересно, что flip работает и с функциями, которые не являются бинарными: он меняет местами первые два аргумента, оставляя остальные в прежнем порядке. Это объясняется тем, что функция, принимающая n+2 аргументов, концептуально является бинарной функцией, которая возвращает функцию, принимающую n аргументов. Для функции f : a -> b -> c -> d:

• flip f будет иметь тип b -> a -> c -> d
• fun x -> flip (f x) будет иметь тип a -> c -> b -> d

Использовать flip таким образом с небинарными функциями не рекомендуется из-за негативного влияния на читабельность и понятность кода.

negate

Используется преимущественно для инвертирования предиката в функциях, которым он передаётся, например List.find_all и подобных

Поиск всех списков, которые не пусты, с помощью List.is_empty

  # List.find_all (Fun.negate List.is_empty) [[0]; [1; 2; 3]; []; [4; 5]];;
  - : int list list = [[0]; [1; 2; 3]; [4; 5]]

Поиск всех незанятых путей в заданном списке путей с помощью Sys.file_exists

  # List.find_all (Fun.negate Sys.file_exists);;
  - : string list -> string list = <fun>

compose

Применение List.map к парам с функцией, применяемой ко второму элементу

  # List.map (Fun.compose String.length snd) [1, "one"; 2, "two"; 3, "three"];;
  - : int list = [3; 3; 5]

Возможная реализация Fun.negate

  let negate f = Fun.compose not f

В примере chain можно было использовать compose в рекурсивной ветви

  let rec chain = function
    | [] -> Fun.id
    | f :: fs -> Fun.compose f (chain fs)

Или даже лаконичнее:

  let chain fs = List.fold_right Fun.compose fs Fun.id

В примере spellcheck можно было использовать compose и flip, чтобы сократить определение функции до следующего вида:

  # Fun.compose
      (String.spellcheck ~max_dist:(Fun.const 2))
      (Fun.flip List.iter)
    ;;
  - : string list -> string -> string list = <fun>

Как видно здесь, это существенно ухудшает читабельность и затрудняет понимание функции. Ни String.spellcheck, ни Fun.flip не являются унарными, поэтому в этом определении частичное применение взаимодействует с ними нетривиальным образом.

В OCaml в целом не рекомендуется широко использовать эти комбинаторы не только потому, что они могут быстро ухудшить читабельность и затруднить понимание кода, но и потому, что полученные функции часто имеют форму значений и, следовательно, подпадают под ограничение значений (см. раздел 6.1.2 руководства).