Глава 11. Язык OCaml

6 Шаблоны

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

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

Шаблоны представляют собой образцы, позволяющие выбирать структуры данных заданной формы и связывать идентификаторы с компонентами структуры данных. Эта операция выбора называется сопоставлением с образцом; её результатом является либо «это значение не соответствует этому шаблону», либо «это значение соответствует этому шаблону, в результате чего имена связываются со следующими значениями».

Шаблоны-переменные

Шаблон, состоящий из имени значения, соответствует любому значению и связывает это имя с данным значением. Шаблон _ также соответствует любому значению, но не связывает ни одного имени.

# let is_empty = function
    | [] -> true
    | _ :: _ -> false;;

val is_empty : 'a list -> bool = 

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

# let pair_equal = function
    | x, x -> true
    | x, y -> false;;

Error: Variable x is bound several times in this matching

Однако для этой цели можно использовать защитное условие when:

# let pair_equal = function
    | x, y when x = y -> true
    | _ -> false;;

val pair_equal : 'a * 'a -> bool = 

Шаблоны-константы

Шаблон, состоящий из константы, соответствует значениям, равным этой константе.

# let bool_of_string = function
    | "true" -> true
    | "false" -> false
    | _ -> raise (Invalid_argument "bool_of_string");;

val bool_of_string : string -> bool = 

Шаблоны-псевдонимы

Шаблон pattern₁ as value-name соответствует тем же значениям, что и pattern₁. Если сопоставление с pattern₁ успешно, имя value-name связывается с сопоставленным значением в дополнение к связям, созданным при сопоставлении с pattern₁.

# let sort_pair ((x, y) as p) =
    if x <= y then p else (y, x);;

val sort_pair : 'a * 'a -> 'a * 'a = 

Шаблоны в скобках

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

# let int_triple_is_ordered ((a, b, c) : int * int * int) =
    a <= b && b <= c;;

val int_triple_is_ordered : int * int * int -> bool = 

Шаблоны «или»

Шаблон pattern₁ | pattern₂ представляет собой логическое «или» двух шаблонов pattern₁ и pattern₂. Значение соответствует шаблону pattern₁ | pattern₂, если оно соответствует pattern₁ или pattern₂. Оба подшаблона pattern₁ и pattern₂ должны связывать одни и те же идентификаторы со значениями одинаковых типов. Сопоставление выполняется слева направо. Точнее, если значение v соответствует шаблону pattern₁ | pattern₂, то создаются связи шаблона pattern₁, если v соответствует pattern₁. В противном случае значение v соответствует шаблону pattern₂, и создаются связи этого шаблона.

# type shape = Square of float | Rect of (float * float) | Circle of float

  let is_rectangular = function
    | Square _ | Rect _ -> true
    | Circle _ -> false;;

type shape = Square of float | Rect of (float * float) | Circle of float
val is_rectangular : shape -> bool = 

Шаблоны вариантов

Шаблон constr ( pattern₁ , … , pattern_n ) соответствует всем вариантам, конструктор которых равен constr, а аргументы соответствуют pattern₁ … pattern_n. Если n не совпадает с числом аргументов, ожидаемым конструктором, возникает ошибка типа.

Шаблон constr _ соответствует всем вариантам, конструктором которых является constr.

# type 'a tree = Lf | Br of 'a tree * 'a * 'a tree

  let rec total = function
    | Br (l, x, r) -> total l + x + total r
    | Lf -> 0;;

type 'a tree = Lf | Br of 'a tree * 'a * 'a tree
val total : int tree -> int = 

Шаблон pattern₁ :: pattern₂ соответствует непустым спискам, головы которых соответствуют pattern₁, а хвосты — pattern₂.

Шаблон [ pattern₁ ; … ; pattern_n ] соответствует спискам длины n, элементы которых соответственно соответствуют pattern₁ …pattern_n. Этот шаблон эквивалентен шаблону pattern₁ :: … :: pattern_n :: [].

# let rec destutter = function
    | [] -> []
    | [a] -> [a]
    | a :: b :: t -> if a = b then destutter (b :: t) else a :: destutter (b :: t);;

val destutter : 'a list -> 'a list = 

Шаблоны полиморфных вариантов

Шаблон `tag-name pattern₁ соответствует всем полиморфным вариантам с тегом tag-name, аргумент которых соответствует pattern₁.

# let rec split = function
    | [] -> ([], [])
    | h :: t ->
        let ss, gs = split t in
          match h with
          | `Sheep _ as s -> (s :: ss, gs)
          | `Goat _ as g -> (ss, g :: gs);;

val split :
  [< `Goat of 'a | `Sheep of 'b ] list ->
  [> `Sheep of 'b ] list * [> `Goat of 'a ] list = 

Шаблоны-сокращения полиморфных вариантов

Если определён тип [('a,'b,…)] typeconstr = [ `tag-name<sub>1</sub> typexpr<sub>1</sub> | … | `tag-name_n typexpr_n], то шаблон #typeconstr является сокращением следующего шаблона «или»: ( `tag-name<sub>1</sub>(_ : typexpr<sub>1</sub>) | … | `tag-name_n(_ : typexpr_n)). Он соответствует всем значениям типа [< typeconstr ].

# type 'a rectangle = [`Square of 'a | `Rectangle of 'a * 'a]
  type 'a shape = [`Circle of 'a | 'a rectangle]

  let try_rectangle = function
    | #rectangle as r -> Some r
    | `Circle _ -> None;;

type 'a rectangle = [ `Rectangle of 'a * 'a | `Square of 'a ]
type 'a shape = [ `Circle of 'a | `Rectangle of 'a * 'a | `Square of 'a ]
val try_rectangle :
  [< `Circle of 'a | `Rectangle of 'b * 'b | `Square of 'b ] ->
  [> `Rectangle of 'b * 'b | `Square of 'b ] option = 

Шаблоны кортежей

Шаблон pattern₁ , … , pattern_n соответствует кортежам из n элементов, компоненты которых соответствуют шаблонам от pattern₁ до pattern_n. Иными словами, шаблон соответствует значениям-кортежам (v₁, …, v_n), таким что pattern_i соответствует v_i для i = 1,… , n.

# let vector (x0, y0) (x1, y1) =
    (x1 -. x0, y1 -. y0);;

val vector : float * float -> float * float -> float * float = 

Шаблоны записей

Шаблон { field₁ [= pattern₁] ; … ; field_n [= pattern_n] } соответствует записям, содержащим как минимум поля с field₁ по field_n, при этом значение, связанное с field_i, соответствует шаблону pattern_i для i = 1,… , n. Один идентификатор field_k означает field_k = field_k, а один квалифицированный идентификатор module-path . field_k означает module-path . field_k = field_k. Запись может содержать больше полей, чем field₁ …field_n; связанные с этими дополнительными полями значения при сопоставлении не учитываются. В конце шаблона записи можно указать ; _, чтобы явно обозначить, что в шаблоне перечислены не все поля типа записи. Для каждого поля можно добавить необязательное ограничение типа, используя запись вида { field₁ : typexpr₁ = pattern₁ ;… ;field_n : typexpr_n = pattern_n }, чтобы потребовать совместимости типа поля field_k с типом typexpr_k.

# let bytes_allocated
      {Gc.minor_words = minor;
       Gc.major_words = major;
       Gc.promoted_words = prom;
       _}
    =
      (Sys.word_size / 4) * int_of_float (minor +. major -. prom);;

val bytes_allocated : Gc.stat -> int = 

Шаблоны массивов

Шаблон [| pattern₁ ; … ; pattern_n |] соответствует массивам длины n, в которых элемент массива с индексом i соответствует шаблону pattern_i для i = 1,… , n.

# let matrix3_is_symmetric = function
    | [|[|_; b; c|];
        [|d; _; f|];
        [|g; h; _|]|] -> b = d && c = g && f = h
    | _ -> failwith "matrix3_is_symmetric: not a 3x3 matrix";;

val matrix3_is_symmetric : 'a array array -> bool = 

Шаблоны диапазонов

Шаблон ' c ' .. ' d ' является сокращением шаблона

где c₁, c₂, …, c_n — символы, расположенные между c и d в наборе символов ASCII. Например, шаблон '0'..'9' соответствует всем цифрам.

# type char_class = Uppercase | Lowercase | Digit | Other

  let classify_char = function
    | 'A'..'Z' -> Uppercase
    | 'a'..'z' -> Lowercase
    | '0'..'9' -> Digit
    | _ -> Other;;

type char_class = Uppercase | Lowercase | Digit | Other
val classify_char : char -> char_class = 

Ленивые шаблоны

(Добавлено в Objective Caml 3.11)

Шаблон lazy pattern соответствует значению v типа Lazy.t, если pattern соответствует результату принудительного вычисления v с помощью Lazy.force. Успешное сопоставление с шаблоном, содержащим подшаблоны lazy, приводит к принудительному вычислению соответствующих частей сопоставляемого значения, в том числе тех, которые не требуют проверки, например lazy value-name или lazy _. Сопоставление значения с помощью pattern-matching, в котором некоторые шаблоны содержат подшаблоны lazy, может привести к принудительному вычислению частей значения, даже если в итоге выбранный шаблон не содержит подшаблонов lazy.

# let force_opt = function
    | Some (lazy n) -> n
    | None -> 0;;

val force_opt : int lazy_t option -> int = 

Дополнительную информацию см. в описании модуля Lazy в стандартной библиотеке (модуль Lazy).

Шаблоны исключений

(Добавлено в OCaml 4.02)

Новая форма шаблона исключения, exception pattern , допускается только в качестве шаблона верхнего уровня или внутри or-шаблона верхнего уровня в сопоставлении с образцом match...with (другие варианты использования отклоняются проверкой типов).

Варианты с таким шаблоном верхнего уровня называются «вариантами исключения», в отличие от обычных «вариантов значения». Варианты исключения применяются, когда при вычислении сопоставляемого выражения возникает исключение. Затем значение исключения сопоставляется со всеми вариантами исключения и повторно вызывается, если ни один из них не принимает это исключение (как в блоке try...with). Поскольку тела всех вариантов исключения и значения находятся вне области действия обработчика исключений, они все считаются находящимися в хвостовой позиции: если сам блок match...with находится в хвостовой позиции текущей функции, любой вызов функции в хвостовой позиции в одном из тел вариантов приводит к фактическому хвостовому вызову.

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

# let find_opt p l =
    match List.find p l with
    | exception Not_found -> None
    | x -> Some x;;

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

Локальные открытия для шаблонов

(Добавлено в OCaml 4.04)

Для шаблонов локальные открытия ограничены конструкцией module-path.(pattern). Эта конструкция локально открывает модуль, указанный путём модуля module-path, в области видимости шаблона pattern.

Если тело шаблона с локальным открытием ограничено символами [ ], [| |] или { }, круглые скобки можно опустить. Например, module-path.[pattern] эквивалентно module-path.([pattern]), а module-path.[| pattern |] эквивалентно module-path.([| pattern |]).

# let bytes_allocated Gc.{minor_words; major_words; promoted_words; _} =
      (Sys.word_size / 4)
    * int_of_float (minor_words +. major_words -. promoted_words);;

val bytes_allocated : Gc.stat -> int =