Глава 11 Язык OCaml

7 Выражения

• 7.1 Приоритет и ассоциативность
• 7.2 Базовые выражения
• 7.3 Конструкции управления
• 7.4 Операции над структурами данных
• 7.5 Операторы
• 7.6 Объекты
• 7.7 Приведения типов
• 7.8 Другое

См. также следующие расширения языка: модули первого класса, переопределение в операторах open, синтаксис для доступа к Bigarray, атрибуты, узлы расширения и расширенные операторы индексирования.

7.1 Приоритет и ассоциативность

Таблица ниже показывает относительные приоритеты и ассоциативность операторов и незамкнутых конструкций. Конструкции с более высоким приоритетом идут первыми. Для инфиксных и префиксных символов мы пишем «*…», чтобы обозначить «любой символ, начинающийся с *».

Проверить или освежить свои знания очень просто:

# 3 + 3 mod 2, 3 + (3 mod 2), (3 + 3) mod 2;;

- : int * int * int = (4, 4, 0)

7.2 Базовые выражения

Константы

Выражение, состоящее из константы, вычисляется в эту константу. Например, 3.14 или [||].

Пути к значениям

Выражение, состоящее из пути доступа, вычисляется в значение, привязанное к этому пути в текущей среде выполнения. Путь может быть именем значения или путем доступа к компоненту значения модуля.

# Float.ArrayLabels.to_list;;

- : Float.ArrayLabels.t -> float list = 

Выражения в скобках

Выражения ( expr ) и begin expr end имеют то же значение, что и expr. Две конструкции семантически эквивалентны, но рекомендуется использовать begin … end внутри управляющих структур:

        if … then begin … ; … end else begin … ; … end

а ( … ) для других ситуаций группировки.

# let x = 1 + 2 * 3
  let y = (1 + 2) * 3;;

val x : int = 7
val y : int = 9

# let f a b =
    if a = b then
      print_endline "Equal"
    else begin
        print_string "Not Equal: ";
        print_int a;
        print_string " and ";
        print_int b;
        print_newline ()
    end;;

val f : int -> int -> unit = 

Выражения в скобках могут содержать ограничение типа, как в ( expr : typexpr ). Это ограничение заставляет тип expr быть совместимым с typexpr.

Выражения в скобках также могут содержать приведения типов ( expr [: typexpr] :> typexpr) (см. подраздел ‍11.7.7 ниже).

Применение функции

Применение функции обозначается примыканием (возможно, именованных) выражений. Выражение expr argument₁ … argument_n вычисляет выражение expr и те, которые появляются в argument₁ до argument_n. Выражение expr должно вычисляться в функциональное значение f, которое затем применяется к значениям argument₁, …, argument_n.

Порядок, в котором вычисляются выражения expr, argument₁, …, argument_n, не указан.

# List.fold_left ( + ) 0 [1; 2; 3; 4; 5];;

- : int = 15

Аргументы и параметры сопоставляются в соответствии с их метками. Порядок аргументов не имеет значения, за исключением аргументов с одной и той же меткой или без метки.

# ListLabels.fold_left ~f:( @ ) ~init:[] [[1; 2; 3]; [4; 5; 6]; [7; 8; 9]];;

- : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9]

Если параметр указан как необязательный (метка, опережаемая ?) в типе expr, соответствующий аргумент будет автоматически обернут конструктором Some, если только сам аргумент также не опережается ?, в этом случае он передается как есть.

# let fullname ?title first second =
    match title with
    | Some t -> t ^ " " ^ first ^ " " ^ second
    | None -> first ^ " " ^ second

  let name = fullname ~title:"Mrs" "Jane" "Fisher"

  let address ?title first second town =
    fullname ?title first second ^ "\n" ^ town;;

val fullname : ?title:string -> string -> string -> string = 
val name : string = "Mrs Jane Fisher"
val address : ?title:string -> string -> string -> string -> string = 

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

# let fullname ?title first second =
    match title with
    | Some t -> t ^ " " ^ first ^ " " ^ second
    | None -> first ^ " " ^ second

  let name = fullname "Jane" "Fisher";;

val fullname : ?title:string -> string -> string -> string = 
val name : string = "Jane Fisher"

Во всех случаях, кроме точного совпадения порядка и меток, без необязательных параметров, тип функции должен быть известен в точке применения. Это можно обеспечить, добавив ограничение типа. Принципиальность вывода может быть проверена в режиме -principal.

В качестве частного случая OCaml поддерживает полные применения с labels-omitted: если функция имеет известную арность, все аргументы неименованные, и их количество совпадает с количеством обязательных параметров, то метки игнорируются, и обязательные параметры сопоставляются в порядке их определения. Необязательные аргументы принимают значения по умолчанию. Это пропуск меток не рекомендуется и приводит к предупреждению, см. 13.5.1.

Определение функции

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

Это выражение вычисляется в функциональное значение с одним аргументом. Когда эта функция применяется к значению v, это значение сопоставляется с каждым шаблоном pattern₁ до pattern_n. Если одно из этих сопоставлений завершается успешно, то есть, если значение v соответствует шаблону pattern_i для некоторого i, то выражение expr_i, связанное с выбранным шаблоном, вычисляется, и его значение становится значением применения функции. Вычисление expr_i происходит в среде, обогащенной связываниями, выполненными во время сопоставления.

Если несколько шаблонов соответствуют аргументу v, выбирается тот, который встречается первым в определении функции. Если ни один из шаблонов не соответствует аргументу, генерируется исключение Match_failure.

# (function (0, 0) -> "both zero"
          | (0, _) -> "first only zero"
          | (_, 0) -> "second only zero"
          | (_, _) -> "neither zero")
  (7, 0);;

- : string = "second only zero"

Другая форма определения функции вводится ключевым словом fun:

Это выражение эквивалентно:

# let f = (fun a -> fun b -> fun c -> a + b + c)
  let g = (fun a b c -> a + b + c);;

val f : int -> int -> int -> int = 
val g : int -> int -> int -> int = 

Необязательное ограничение типа typexpr может быть добавлено перед -> для принудительного соответствия типа результата ограничению typexpr:

эквивалентно

Обратите внимание на небольшое синтаксическое различие между ограничением типа на последнем параметре

и ограничением на результате

# let eq = fun (a : int) (b : int) -> a = b
  let eq2 = fun a b : bool -> a = b
  let eq3 = fun (a : int) (b : int) : bool -> a = b;;

val eq : int -> int -> bool = 
val eq2 : 'a -> 'a -> bool = 
val eq3 : int -> int -> bool = 

Шаблоны параметров ~lab и ~(lab [: typ]) являются сокращениями соответственно для ~lab:lab и ~lab:(lab [: typ]), и аналогично для их необязательных аналогов.

# let bool_map ~cmp:(cmp : int -> int -> bool) l =
    List.map cmp l

  let bool_map' ~(cmp : int -> int -> bool) l =
    List.map cmp l;;

val bool_map : cmp:(int -> int -> bool) -> int list -> (int -> bool) list =
  
val bool_map' : cmp:(int -> int -> bool) -> int list -> (int -> bool) list =
  

Функция вида fun ? lab :( pattern = expr₀ ) -> expr эквивалентна

где ident — новая переменная, за исключением того, что она не определена, когда вычисляется expr₀.

# let open_file_for_input ?binary filename =
    match binary with
    | Some true -> open_in_bin filename
    | Some false | None -> open_in filename

  let open_file_for_input' ?(binary=false) filename =
    if binary then open_in_bin filename else open_in filename;;

val open_file_for_input : ?binary:bool -> string -> in_channel = 
val open_file_for_input' : ?binary:bool -> string -> in_channel = 

После этих двух преобразований выражения имеют вид

Если мы игнорируем метки, которые будут иметь значение только при применении функции, это эквивалентно

То есть, выражение fun выше вычисляется в карированную функцию с n аргументами: после применения этой функции n раз к значениям v₁ … v_n, значения будут сопоставлены параллельно с шаблонами pattern₁ … pattern_n. Если сопоставление успешно, функция возвращает значение expr в среде, обогащенной привязками, выполненными во время сопоставлений. Если сопоставление не удается, возникает исключение Match_failure.

Ограничительные условия в сопоставлениях с шаблонами

Случаи сопоставления с шаблонами (в конструкциях function, match и try) могут включать выражения-ограничители, которые представляют собой произвольные булевы выражения, которые должны вычисляться в true для выбора случая сопоставления. Ограничители находятся непосредственно перед маркером -> и вводятся с помощью ключевого слова when:

Сопоставление происходит, как описано выше, за исключением того, что если значение соответствует некоторому шаблону pattern_i, который имеет ограничитель cond_i, то выражение cond_i вычисляется (в среде, обогащенной привязками, выполненными во время сопоставления). Если cond_i вычисляется в true, то expr_i вычисляется и его значение возвращается как результат сопоставления, как обычно. Но если cond_i вычисляется в false, сопоставление возобновляется с шаблонов, следующих за pattern_i.

# let rec repeat f = function
    | 0 -> ()
    | n when n > 0 -> f (); repeat f (n - 1)
    | _ -> raise (Invalid_argument "repeat");;

val repeat : (unit -> 'a) -> int -> unit = 

Локальные определения

Конструкции let и let rec связывают имена значений локально. Конструкция

вычисляет expr₁ … expr_n в каком-то неопределенном порядке и сопоставляет их значения с шаблонами pattern₁ … pattern_n. Если сопоставления успешны, expr вычисляется в среде, обогащенной привязками, выполненными во время сопоставления, и значение expr возвращается как значение всего выражения let. Если одно из сопоставлений не удается, возникает исключение Match_failure.

# let v =
    let x = 1 in [x; x; x]

  let v' =
    let a, b = (1, 2) in a + b

  let v'' =
    let a = 1 and b = 2 in a + b;;

val v : int list = [1; 1; 1]
val v' : int = 3
val v'' : int = 3

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

в выражении let, можно вместо этого написать

# let f = fun x -> fun y -> fun z -> x + y + z

  let f' = fun x y z -> x + y + z

  let f'' x y z = x + y + z;;

val f : int -> int -> int -> int = 
val f' : int -> int -> int -> int = 
val f'' : int -> int -> int -> int = 

Рекурсивные определения имен вводятся с помощью let rec:

Единственное отличие от конструкции let, описанной выше, состоит в том, что привязки имен к значениям, выполняемые сопоставлением с шаблонами, считаются уже выполненными, когда вычисляются выражения expr₁ до expr_n. То есть, выражения expr₁ до expr_n могут ссылаться на идентификаторы, которые связаны одним из шаблонов pattern₁, …, pattern_n, и ожидать, что они будут иметь то же значение, что и в expr, теле конструкции let rec.

# let rec even =
    function 0 -> true | n -> odd (n - 1)
  and odd =
    function 0 -> false | n -> even (n - 1)
  in
    even 1000;;

- : bool = true

Гарантируется, что рекурсивное определение будет вести себя, как описано выше, если выражения expr₁ до expr_n являются определениями функций (fun … или function …), а шаблоны pattern₁ … pattern_n являются просто именами значений, как в:

Это определяет name₁ … name_n как взаимно рекурсивные функции, локальные для expr.

Поведение других форм определений let rec зависит от реализации. Текущая реализация также поддерживает определенный класс рекурсивных определений не функциональных значений, как объясняется в разделе ‍12.1.

Локальные исключения

(Введено в OCaml 4.04)

Можно определить локальные исключения в выражениях: let exception constr-decl in expr .

# let map_empty_on_negative f l =
    let exception Negative in
    let aux x = if x < 0 then raise Negative else f x in
      try List.map aux l with Negative -> [];;

val map_empty_on_negative : (int -> 'a) -> int list -> 'a list = 

Синтаксическая область видимости конструктора исключения — внутреннее выражение, но ничто не мешает значениям исключений, созданным с помощью этого конструктора, выходить за пределы этой области видимости. Два выполнения приведенного выше определения приводят к двум несовместимым конструкторам исключений (как и для любого определения исключения). Например:

# let gen () = let exception A in A

  let () = assert(gen () = gen ());;

Exception: Assert_failure ("expr.etex", 3, 9).

Явные полиморфные аннотации типов

(Введено в OCaml 3.12)

Полиморфные аннотации типов в определениях let ведут себя аналогично полиморфным методам:

Эти аннотации явно требуют, чтобы определенное значение было полиморфным, и позволяют использовать этот полиморфизм в рекурсивных вхождениях (при использовании let rec). Однако следует отметить, что это обычный полиморфный тип, унифицируемый с любым его экземпляром.

7.3 Конструкции управления

Последовательность

Выражение expr₁ ; expr₂ сначала вычисляет expr₁, затем expr₂ и возвращает значение expr₂.

# let print_pair (a, b) =
    print_string "(";
    print_string (string_of_int a);
    print_string ",";
    print_string (string_of_int b);
    print_endline ")";;

val print_pair : int * int -> unit = 

Условное выражение

Выражение if expr₁ then expr₂ else expr₃ вычисляется в значение expr₂, если expr₁ вычисляется в булево значение true, и в значение expr₃, если expr₁ вычисляется в булево значение false.

# let rec factorial x =
    if x <= 1 then 1 else x * factorial (x - 1);;

val factorial : int -> int = 

Часть else expr₃ может быть опущена, в этом случае она по умолчанию равна else ().

# let debug = ref false

  let log msg =
    if !debug then prerr_endline msg;;

val debug : bool ref = {contents = false}
val log : string -> unit = 

Выражение case

Выражение

сопоставляет значение expr с образцами pattern₁ до pattern_n. Если сопоставление с pattern_i завершается успешно, вычисляется связанное выражение expr_i, и его значение становится значением всего выражения match. Вычисление expr_i происходит в среде, дополненной привязками, выполненными во время сопоставления. Если несколько образцов соответствуют значению expr, выбирается тот, который встречается первым в выражении match.

# let rec sum l =
    match l with
    | [] -> 0
    | h :: t -> h + sum t;;

val sum : int list -> int = 

Если ни один из образцов не соответствует значению expr, возникает исключение Match_failure.

# let unoption o =
    match o with
    | Some x -> x ;;

Warning 8 [partial-match]: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
None

val unoption : 'a option -> 'a = 

# let l = List.map unoption [Some 1; Some 10; None; Some 2];;

Exception: Match_failure ("expr.etex", 2, 2).

Булевы операторы

Выражение expr₁ && expr₂ вычисляется в true, если и expr₁, и expr₂ вычисляются в true; в противном случае оно вычисляется в false. Сначала вычисляется первый компонент, expr₁. Второй компонент, expr₂, не вычисляется, если первый компонент вычисляется в false. Следовательно, выражение expr₁ && expr₂ ведет себя точно так же, как

Выражение expr₁ || expr₂ вычисляется в true, если одно из выражений expr₁ и expr₂ вычисляется в true; в противном случае оно вычисляется в false. Сначала вычисляется первый компонент, expr₁. Второй компонент, expr₂, не вычисляется, если первый компонент вычисляется в true. Следовательно, выражение expr₁ || expr₂ ведет себя точно так же, как

Булевы операторы & и or являются устаревшими синонимами для (соответственно) && и ||.

# let xor a b =
    (a || b) && not (a && b);;

val xor : bool -> bool -> bool = 

Циклы

Выражение while expr₁ do expr₂ done многократно вычисляет expr₂, пока expr₁ вычисляется как true. Условие цикла expr₁ вычисляется и проверяется в начале каждой итерации. Всё выражение while … done вычисляется в единичное значение ().

# let chars_of_string s =
    let i = ref 0 in
    let chars = ref [] in
      while !i < String.length s do
        chars := s.[!i] :: !chars;
        i := !i + 1
      done;
      List.rev !chars;;

val chars_of_string : string -> char list = 

В качестве частного случая, while true do expr done имеет полиморфный тип, позволяющий использовать его вместо любого выражения (например, как ветвь любого сопоставления с образцом).

Выражение for name = expr₁ to expr₂ do expr₃ done сначала вычисляет выражения expr₁ и expr₂ (границы) в целочисленные значения n и p. Затем тело цикла expr₃ многократно вычисляется в среде, где name последовательно связывается со значениями n, n+1, …, p−1, p. Тело цикла никогда не вычисляется, если n > p.

# let chars_of_string s =
    let l = ref [] in
      for p = 0 to String.length s - 1 do
        l := s.[p] :: !l
      done;
      List.rev !l;;

val chars_of_string : string -> char list = 

Выражение for name = expr₁ downto expr₂ do expr₃ done вычисляется аналогично, за исключением того, что name последовательно связывается со значениями n, n−1, …, p+1, p. Тело цикла никогда не вычисляется, если n < p.

# let chars_of_string s =
    let l = ref [] in
      for p = String.length s - 1 downto 0 do
        l := s.[p] :: !l
      done;
      !l;;

val chars_of_string : string -> char list = 

В обоих случаях всё выражение for вычисляется в единичное значение ().

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

Выражение

вычисляет выражение expr и возвращает его значение, если вычисление expr не вызывает никаких исключений. Если вычисление expr вызывает исключение, значение исключения сопоставляется с образцами pattern₁ до pattern_n. Если сопоставление с pattern_i успешно, связанное выражение expr_i вычисляется, и его значение становится значением всего выражения try. Вычисление expr_i происходит в среде, дополненной связываниями, выполненными во время сопоставления. Если несколько образцов соответствуют значению expr, выбирается тот, который встречается первым в выражении try. Если ни один из образцов не соответствует значению expr, значение исключения снова вызывается, тем самым прозрачно «проходя» через конструкцию try.

# let find_opt p l =
    try Some (List.find p l) with Not_found -> None;;

val find_opt : ('a -> bool) -> 'a list -> 'a option = 

7.4 Операции над структурами данных

Продукты

Выражение expr₁ , … , expr_n вычисляется в n-кортеж значений выражений expr₁ до expr_n. Порядок вычисления подвыражений не определен.

# (1 + 2 * 3, (1 + 2) * 3, 1 + (2 * 3));;

- : int * int * int = (7, 9, 7)

Варианты

Выражение constr expr вычисляется в унарное значение варианта, конструктор которого — constr, а аргумент — значение expr. Аналогично, выражение constr ( expr₁ , … , expr_n ) вычисляется в n-арное значение варианта, конструктор которого — constr, а аргументы — значения expr₁, …, expr_n.

Выражение constr (expr₁, …, expr_n) вычисляется в значение варианта, конструктор которого — constr, а аргументы — значения expr₁ … expr_n.

# type t = Var of string | Not of t | And of t * t | Or of t * t

  let test = And (Var "x", Not (Or (Var "y", Var "z")));;

type t = Var of string | Not of t | And of t * t | Or of t * t
val test : t = And (Var "x", Not (Or (Var "y", Var "z")))

Для списков предоставляется некоторый синтаксический сахар. Выражение expr₁ :: expr₂ обозначает конструктор ( :: ), примененный к аргументам ( expr₁ , expr₂ ), и, следовательно, вычисляется в список, голова которого — значение expr₁, а хвост — значение expr₂. Выражение [ expr₁ ; … ; expr_n ] эквивалентно expr₁ :: … :: expr_n :: [], и, следовательно, вычисляется в список, элементами которого являются значения expr₁ до expr_n.

# 0 :: [1; 2; 3] = 0 :: 1 :: 2 :: 3 :: [];;

- : bool = true

Полиморфные варианты

Выражение `tag-name expr вычисляется в значение полиморфного варианта, тег которого — tag-name, а аргумент — значение expr.

# let with_counter x = `V (x, ref 0);;

val with_counter : 'a -> [> `V of 'a * int ref ] = 

Записи

Выражение { field₁ [= expr₁] ; … ; field_n [= expr_n ]} вычисляется в значение записи { field₁ = v₁; …; field_n = v_n }, где v_i — значение expr_i для i = 1,… , n. Одиночный идентификатор field_k обозначает field_k = field_k, а квалифицированный идентификатор module-path . field_k обозначает module-path . field_k = field_k. Все поля field₁ до field_n должны принадлежать одному и тому же типу записи; каждое поле этого типа записи должно встречаться в выражении записи ровно один раз, хотя они могут появляться в любом порядке. Порядок, в котором вычисляются expr₁ до expr_n, не указан. После каждого поля можно добавлять необязательные ограничения типа { field₁ : typexpr₁ = expr₁ ;… ; field_n : typexpr_n = expr_n }, чтобы принудительно установить тип field_k совместимым с typexpr_k.

# type t = {house_no : int; street : string; town : string; postcode : string}

  let address x =
    Printf.sprintf "The occupier\n%i %s\n%s\n%s"
      x.house_no x.street x.town x.postcode;;

type t = {
  house_no : int;
  street : string;
  town : string;
  postcode : string;
}
val address : t -> string = 

Выражение { expr with field₁ [= expr₁] ; … ; field_n [= expr_n] } создает новую запись с полями field₁ … field_n, равными expr₁ … expr_n, а все остальные поля имеют то же значение, что и в записи expr. Другими словами, оно возвращает неглубокую копию записи expr, за исключением полей field₁ … field_n, которые инициализируются значениями expr₁ … expr_n. Как и ранее, одиночный идентификатор field_k обозначает field_k = field_k, квалифицированный идентификатор module-path . field_k обозначает module-path . field_k = field_k, и можно добавить необязательное ограничение типа для каждого обновляемого поля с помощью { expr with field₁ : typexpr₁ = expr₁ ; … ; field_n : typexpr_n = expr_n }.

# type t = {house_no : int; street : string; town : string; postcode : string}

  let uppercase_town address =
    {address with town = String.uppercase_ascii address.town};;

type t = {
  house_no : int;
  street : string;
  town : string;
  postcode : string;
}
val uppercase_town : t -> t = 

Выражение expr₁ . field вычисляет expr₁ как значение записи и возвращает значение, связанное с field в этом значении записи.

Выражение expr₁ . field <- expr₂ вычисляет expr₁ как значение записи, которое затем изменяется на месте путем замены значения, связанного с field в этой записи, на значение expr₂. Эта операция разрешена только в том случае, если field был объявлен как mutable в определении типа записи. Всё выражение expr₁ . field <- expr₂ вычисляется в единичное значение ().

# type t = {mutable upper : int; mutable lower : int; mutable other : int}

  let stats = {upper = 0; lower = 0; other = 0}

  let collect =
    String.iter
      (function
       | 'A'..'Z' -> stats.upper <- stats.upper + 1
       | 'a'..'z' -> stats.lower <- stats.lower + 1
       | _ -> stats.other <- stats.other + 1);;

type t = { mutable upper : int; mutable lower : int; mutable other : int; }
val stats : t = {upper = 0; lower = 0; other = 0}
val collect : string -> unit = 

Массивы

Выражение [| expr₁ ; … ; expr_n |] вычисляется в массив из n элементов, элементы которого инициализируются значениями expr₁ до expr_n соответственно. Порядок, в котором вычисляются эти выражения, не определен.

Выражение expr₁ .( expr₂ ) возвращает значение элемента под номером expr₂ в массиве, обозначаемом expr₁. Первый элемент имеет номер 0; последний элемент имеет номер n−1, где n — размер массива. Если доступ выходит за границы, возникает исключение Invalid_argument.

Выражение expr₁ .( expr₂ ) <- expr₃ изменяет на месте массив, обозначаемый expr₁, заменяя элемент под номером expr₂ на значение expr₃. Если доступ выходит за границы, возникает исключение Invalid_argument. Значение всего выражения — ().

# let scale arr n =
    for x = 0 to Array.length arr - 1 do
      arr.(x) <- arr.(x) * n
    done

  let x = [|1; 10; 100|]
  let _ = scale x 2;;

val scale : int array -> int -> unit = 
val x : int array = [|2; 20; 200|]

Строки

Выражение expr₁ .[ expr₂ ] возвращает значение символа под номером expr₂ в строке, обозначаемой expr₁. Первый символ имеет номер 0; последний символ имеет номер n−1, где n — длина строки. Если доступ выходит за границы, возникает исключение Invalid_argument.

# let iter f s =
    for x = 0 to String.length s - 1 do f s.[x] done;;

val iter : (char -> 'a) -> string -> unit = 

Выражение expr₁ .[ expr₂ ] <- expr₃ изменяет на месте строку, обозначаемую expr₁, заменяя символ под номером expr₂ на значение expr₃. Если доступ выходит за границы, возникает исключение Invalid_argument. Значение всего выражения — (). Примечание: эта возможность предоставляется только для обратной совместимости со старыми версиями OCaml и будет удалена в будущей версии. В новом коде следует использовать последовательности байтов и функцию Bytes.set.

7.5 Операторы

Символы из класса infix-symbol, а также ключевые слова *, +, -, -., =, !=, <, >, or, ||, &, &&, :=, mod, land, lor, lxor, lsl, lsr и asr могут появляться в инфиксной позиции (между двумя выражениями). Символы из класса prefix-symbol, а также ключевые слова - и -. могут появляться в префиксной позиции (перед выражением).

# (( * ), ( := ), ( || ));;

- : (int -> int -> int) * ('a ref -> 'a -> unit) * (bool -> bool -> bool) =
(, , )

Инфиксные и префиксные символы не имеют фиксированного значения: они просто интерпретируются как применения функций, связанных с именами, соответствующими символам. Выражение prefix-symbol expr интерпретируется как применение ( prefix-symbol ) expr. Аналогично, выражение expr₁ infix-symbol expr₂ интерпретируется как применение ( infix-symbol ) expr₁ expr₂.

В таблице ниже перечислены символы, определенные в начальной среде, и их начальное значение. (Дополнительные сведения см. в описании модуля основной библиотеки Stdlib в главе ‍28). Их значение может быть изменено в любое время с помощью let ( infix-op ) name₁ name₂ = …

# let ( + ), ( - ), ( * ), ( / ) = Int64.(add, sub, mul, div);;

val ( + ) : int64 -> int64 -> int64 = 
val ( - ) : int64 -> int64 -> int64 = 
val ( * ) : int64 -> int64 -> int64 = 
val ( / ) : int64 -> int64 -> int64 = 

Примечание: операторы &&, || и ~- обрабатываются специально, и не рекомендуется изменять их значение.

Ключевые слова - и -. могут выступать как инфиксные и префиксные операторы. Когда они выступают как префиксные операторы, они интерпретируются соответственно как функции (~-) и (~-.).

7.6 Объекты

Создание объектов

Когда class-path вычисляется как тело класса, new class-path вычисляется как новый объект, содержащий переменные и методы экземпляра этого класса.

# class of_list (lst : int list) = object
    val mutable l = lst
    method next =
      match l with
      | [] -> raise (Failure "empty list");
      | h::t -> l <- t; h
  end

  let a = new of_list [1; 1; 2; 3; 5; 8; 13]

  let b = new of_list;;

class of_list :
  int list -> object val mutable l : int list method next : int end
val a : of_list = 
val b : int list -> of_list = 

Когда class-path вычисляется как функция класса, new class-path вычисляется как функция, ожидающая то же количество аргументов и возвращающая новый объект этого класса.

Непосредственное создание объектов

Создание объекта напрямую с помощью конструкции object class-body end оперативно эквивалентно локальному определению class class-name = object class-body end —см. разделы 11.9.2 и следующие за ним для синтаксиса class-body— и непосредственному созданию одного объекта из него с помощью new class-name.

# let o =
    object
      val secret = 99
      val password = "unlock"
      method get guess = if guess <> password then None else Some secret
    end;;

val o : < get : string -> int option > = 

Типизация непосредственных объектов немного отличается от явного определения класса в двух аспектах. Во-первых, выведенный тип объекта может содержать свободные переменные типа. Во-вторых, поскольку тело класса непосредственного объекта никогда не будет расширено, его собственный тип может быть объединен с закрытым типом объекта.

Вызов метода

Выражение expr # method-name вызывает метод method-name объекта, обозначаемого expr.

# class of_list (lst : int list) = object
    val mutable l = lst
    method next =
      match l with
      | [] -> raise (Failure "empty list");
      | h::t -> l <- t; h
  end

  let a = new of_list [1; 1; 2; 3; 5; 8; 13]

  let third = ignore a#next; ignore a#next; a#next;;

class of_list :
  int list -> object val mutable l : int list method next : int end
val a : of_list = 
val third : int = 2

Если method-name является полиморфным методом, его тип должен быть известен в точке вызова. Это верно, например, если expr является именем нового объекта (let ident = new class-path … ) или если существует ограничение типа. Принцип вывода может быть проверен в режиме -principal.

Доступ к переменным экземпляра и их изменение

Переменные экземпляра класса видны только в теле методов, определенных в этом же классе или классе, который наследуется от класса, определяющего переменные экземпляра. Выражение inst-var-name вычисляет значение данной переменной экземпляра. Выражение inst-var-name <- expr присваивает значение expr переменной экземпляра inst-var-name, которая должна быть изменяемой. Всё выражение inst-var-name <- expr вычисляет в ().

# class of_list (lst : int list) = object
    val mutable l = lst
    method next =
      match l with                            (* access instance variable *)
      | [] -> raise (Failure "empty list");
      | h::t -> l <- t; h                     (* modify instance variable *)
  end;;

class of_list :
  int list -> object val mutable l : int list method next : int end

Дублирование объектов

Объект можно дублировать с помощью библиотечной функции Oo.copy (см. модуль Oo). Внутри метода выражение {< [inst-var-name [= expr] { ; inst-var-name [= expr] }] >} возвращает копию self с заданными переменными экземпляра, замененными значениями соответствующих выражений. Одиночное имя переменной экземпляра id означает id = id. Другие переменные экземпляра имеют в возвращаемом объекте то же значение, что и в self.

# let o =
    object
      val secret = 99
      val password = "unlock"
      method get guess = if guess <> password then None else Some secret
      method with_new_secret s = {< secret = s >}
    end;;

val o : < get : string -> int option; with_new_secret : int -> 'a > as 'a =
  

7.7 Приведение типов

Выражения, тип которых содержит объектные или полиморфные вариантные типы, могут быть явно приведены (ослаблены) к супертипу. Выражение (expr :> typexpr) приводит выражение expr к типу typexpr. Выражение (expr : typexpr₁ :> typexpr₂) приводит выражение expr из типа typexpr₁ к типу typexpr₂.

Первый оператор иногда не сможет привести выражение expr из типа typ₁ к типу typ₂, даже если тип typ₁ является подтипом типа typ₂: в текущей реализации он раскрывает только два уровня сокращений типов, содержащих объекты и/или полиморфные варианты, сохраняя только рекурсию, когда она явная в типе класса (для объектов). В качестве исключения из вышеуказанного алгоритма, если и выведенный тип expr, и typ являются основными (т.е. не содержат переменных типа), первый оператор ведет себя как второй, принимая выведенный тип expr как typ₁. В случае сбоя с первым оператором, следует использовать второй.

Привести выражение expr из типа typ₁ к типу typ₂ возможно только в том случае, если тип expr является экземпляром typ₁ (как для аннотации типа), и typ₁ является подтипом typ₂. Тип приведенного выражения является экземпляром typ₂. Если типы содержат переменные, они могут быть инстанцированы алгоритмом подтипирования, но это делается только после определения того, является ли typ₁ потенциальным подтипом typ₂. Это означает, что типизация может завершиться неудачей на этом последнем этапе унификации, даже если некоторый экземпляр typ₁ является подтипом некоторого экземпляра typ₂. В следующих параграфах мы опишем используемое отношение подтипирования.

Объектные типы

Фиксированный объектный тип допускает в качестве подтипа любой объектный тип, который включает все его методы. Типы методов должны быть подтипами тех, которые находятся в супертипе. А именно,

является супертипом

который может содержать многоточие .., если каждый typ_i является супертипом соответствующего typ′_i.

Мономорфный тип метода может быть супертипом полиморфного типа метода. А именно, если typ является экземпляром typ′, то 'a₁ … 'a_n . typ′ является подтипом typ.

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

Полиморфные вариантные типы

Полиморфный вариантный тип typ является подтипом другого полиморфного вариантного типа typ′ если верхняя граница typ (т.е. максимальное множество конструкторов, которые могут появиться в экземпляре typ) включено в нижнюю границу typ′, и типы аргументов для конструкторов typ являются подтипами тех, которые находятся в typ′. А именно,

который может быть сокращаемым типом, является подтипом

который может быть расширяемым типом, если каждый typ_i является подтипом typ′_i.

Дисперсия

Другие типы не вводят нового подтипирования, но они могут распространять подтипирование своих аргументов. Например, typ₁ * typ₂ является подтипом typ′₁ * typ′₂, когда typ₁ и typ₂ являются соответственно подтипами typ′₁ и typ′₂. Для функциональных типов отношение более тонкое: typ₁ -> typ₂ является подтипом typ′₁ ‍-> typ′₂, если typ₁ является супертипом typ′₁, а typ₂ является подтипом typ′₂. По этой причине функциональные типы ковариантны по своему второму аргументу (как кортежи), но контравариантны по своему первому аргументу. Изменяемые типы, такие как array или ref, не являются ни ковариантными, ни контравариантными, они невариантны, то есть они не распространяют подтипирование.

Для определяемых пользователем типов дисперсия выводится автоматически: параметр является ковариантным, если он имеет только ковариантные вхождения, контравариантным, если он имеет только контравариантные вхождения, без дисперсии, если он не имеет вхождений, и невариантным в противном случае. Параметр без дисперсии может свободно изменяться при подтипировании, он не должен быть подтипом или супертипом. Для абстрактных и закрытых типов дисперсию необходимо задавать явно (см. раздел ‍11.8.1), иначе по умолчанию используется невариантность. Это также относится к ограниченным аргументам в определениях типов.

7.8 Другие

Проверка утверждений

OCaml поддерживает конструкцию assert для проверки утверждений отладки. Выражение assert expr вычисляет выражение expr и возвращает (), если expr вычисляется как true. Если оно вычисляется как false, возникает исключение Assert_failure с именем исходного файла и местоположением expr в качестве аргументов. Проверку утверждений можно отключить с помощью параметра компилятора -noassert. В этом случае expr вообще не вычисляется.

# let f a b c =
    assert (a <= b && b <= c);
    (b -. a) /. (c -. b);;

val f : float -> float -> float -> float = 

В качестве особого случая, assert false сводится к raise (Assert_failure ...), что дает ему полиморфный тип. Это означает, что он может использоваться вместо любого выражения (например, как ветвь любого сопоставления с образцом). Это также означает, что «утверждения» assert false не могут быть отключены с помощью параметра -noassert.

# let min_known_nonempty = function
    | [] -> assert false
    | l -> List.hd (List.sort compare l);;

val min_known_nonempty : 'a list -> 'a = 

Ленивые выражения

Выражение lazy expr возвращает значение v типа Lazy.t, которое инкапсулирует вычисление expr. Аргумент expr не вычисляется в этой точке программы. Вместо этого его вычисление будет выполнено в первый раз, когда функция Lazy.force применяется к значению v, возвращая фактическое значение expr. Последующие применения Lazy.force к v не вычисляют expr снова. Применения Lazy.force могут быть неявными через сопоставление с образцом (см. ‍11.6).

# let lazy_greeter = lazy (print_string "Hello, World!\n");;

val lazy_greeter : unit lazy_t = 

# Lazy.force lazy_greeter;;

Hello, World!
- : unit = ()

Локальные модули

Выражение let module module-name = module-expr in expr локально связывает выражение модуля module-expr с идентификатором module-name во время вычисления выражения expr. Затем он возвращает значение expr. Например:

# let remove_duplicates comparison_fun string_list =
    let module StringSet =
      Set.Make(struct type t = string
                      let compare = comparison_fun end)
    in
      StringSet.elements
        (List.fold_right StringSet.add string_list StringSet.empty);;

val remove_duplicates :
  (string -> string -> int) -> string list -> string list = 

Локальное открытие

Выражения let open module-path in expr и module-path.(expr) строго эквивалентны. Эти конструкции локально открывают модуль, на который ссылается путь к модулю module-path, в соответствующей области действия выражения expr.

# let map_3d_matrix f m =
    let open Array in
      map (map (map f)) m

  let map_3d_matrix' f =
    Array.(map (map (map f)));;

val map_3d_matrix :
  ('a -> 'b) -> 'a array array array -> 'b array array array = 
val map_3d_matrix' :
  ('a -> 'b) -> 'a array array array -> 'b array array array = 

Когда тело локального открытого выражения ограничено [ ], [| |] или { }, скобки могут быть опущены. Для выражения скобки также могут быть опущены для {< >}. Например, module-path.[expr] эквивалентно module-path.([expr]), и module-path.[| expr |] эквивалентно module-path.([| expr |]).

# let vector = Random.[|int 255; int 255; int 255; int 255|];;

val vector : int array = [|220; 90; 247; 144|]