9.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 = 

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

Шаблон { поле₁ [= шаблон₁] ; … ; поле_n [= шаблон_n] } сопоставляет записи, которые определяют по крайней мере поля поле₁ до поле_n, и такие, что значение, связанное с полем_i, соответствует шаблону шаблону_i, для i = 1,… , n. Единственный идентификатор поле_k обозначает поле_k = поле_k, а единственный квалифицированный идентификатор путь-модуля . поле_k обозначает путь-модуля . поле_k = поле_k. Значение записи может определить больше полей, чем поле₁ …поле_n; значения, связанные с этими дополнительными полями, не учитываются при сопоставлении. Необязательно, шаблон записи может завершаться ; _ для того, чтобы указать на то, что не все поля типа записи перечислены в шаблоне записи и что это сделано намеренно. Необязательные ограничения типов могут быть добавлены поле за полем с { поле₁ : типвыражение₁ = шаблон₁ ;… ;поле_n : типвыражение_n = шаблон_n } для принудительного приведения типа поле_k к совместимому с типвыражение_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 = 

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

Шаблон [| шаблон₁ ; … ; шаблон_n |] соответствует массивам длины n таким, что i-й элемент массива соответствует шаблону шаблон_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 шаблон соответствует значению v типа Lazy.t, при условии, что шаблон соответствует результату принудительного вычисления v с помощью Lazy.force. Успешное сопоставление шаблона, содержащего подшаблоны lazy, принуждает соответствующие части сопоставляемого значения, даже те, которые не подразумевают проверки, такие как lazy имя-значения или lazy _. Сопоставление значения с сопоставлением-шаблонов, где некоторые шаблоны содержат подшаблоны 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 шаблон , разрешен только как шаблон верхнего уровня или внутри шаблона «или» верхнего уровня под 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 |]).

# 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 =