Просмотр кода страницы OCaml

{{Карточка языка программирования}}

'''OCaml''' (''Objective Caml'') — [[Объектно-ориентированное программирование|объектно-ориентированный]] [[язык функционального программирования]] общего назначения, самый распространённый в практической работе диалект языка [[ML]]. Был разработан с учётом безопасности исполнения и надёжности программ. Поддерживает функциональную, императивную и объектно-ориентированную парадигмы программирования. 

Появился в [[1996 год]]у под названием Objective Caml, когда Дидье Реми (''Didier Rémy'') и Жером Вуйон (''Jérôme Vouillon'') реализовали поддержку объектно-ориентированного программирования для языка Caml, первоначально разработанного во французском институте [[INRIA]]. Официально переименован в OCaml в 2011 году<ref>{{Cite web |url=http://ocaml.org/learn/history.html |title=A History of OCaml |access-date=2019-04-22 |archive-date=2015-09-01 |archive-url=https://web.archive.org/web/20150901152031/http://ocaml.org/learn/history.html |url-status=live }}</ref>.

Инструментарий OCaml включает в себя [[интерпретатор]], [[компилятор]] в [[байткод]] и оптимизирующий компилятор в [[машинный код]], сравнимый по эффективности с [[Java]] и лишь немного уступающий по быстродействию [[Си (язык программирования)|C]] и [[C++]]{{sfn|Minsky|2011}}.

На языке, в частности, написан [[рендеринг]] [[Математическая формула|формул]] [[Википедия|Википедии]], использующих тег <nowiki><math></nowiki>, файлообменный клиент [[MLDonkey]], стек управления гипервизором [[Xen]] xapi (является частью Xen Server/Xen Cloud Platform), язык программирования [[Haxe]].

== Роль в информатике ==
Является языком программирования общего назначения, но при этом имеет свои сложившиеся области применения{{sfn|Smith|2006|p=2—3}}.

Во-первых, это — создание «безопасных» (не только в смысле информационной безопасности) приложений. В языке используется сборка мусора, а большинство типов данных является ссылочным ({{lang-en|boxed}}), что означает предотвращение [[Переполнение буфера|переполнения буферов]] во время исполнения программы. Кроме того, статическая типизация и проверки времени компиляции делают невозможными некоторые другие классы ошибок, такие, как ошибки [[Приведение типа|приведения типов]] в силу отсутствия автоматического приведения типов. Кроме того, код может быть [[формальная верификация|формально верифицирован]]. Имеются утилиты автоматического доказательства типовой корректности кода, превосходящие таковые для большинства языков программирования. И что немаловажно, меры безопасности не влияют на эффективность исполняемого кода{{sfn|Smith|2006|p=2—3}}.

Другой областью успешного применения OCaml являются приложения, [[Программирование, управляемое данными|управляемые данными]] (data-driven). К этой области относится обработка текста, а также написание компиляторов. OCaml имеет не только средства для текстовой обработки (какими славится, например, [[Perl]] или [[AWK]]), но и инструменты для глубокого семантического анализа и преобразования текста, что делает OCaml применимым в задачах [[data mining|интеллектуального анализа данных]] ({{lang-en|data mining}}){{sfn|Smith|2006|p=2—3}}.

OCaml, как и другие диалекты ML, используются в исследовательских задачах и задачах верификации, при котором основной код пишется на некотором языке программирования, а затем формально верифицируется и анализируется программой на OCaml{{sfn|Smith|2006|p=2—3}}. Например, на OCaml написана система интерактивного доказательства теорем [[Coq]].

Занимает особое место среди языков программирования благодаря сочетанию эффективности, выразительности и практичности. Среди особенностей языка, развивавшихся в течение более чем 40 лет, со времени создания [[ML]], выделяют следующие{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Why OCaml?}}:
* [[Статическая типизация|статическая проверка типов]],
* [[параметрический полиморфизм]],
* [[функции первого класса]],
* [[Алгебраический тип данных|алгебраические типы данных]] и [[сопоставление с образцом]],
* поддержка программирования с неизменяемыми структурами данных ({{lang-en|immutable programming}}),
* автоматическая [[сборка мусора (программирование)|сборка мусора]],
* эффективный компилятор в [[машинный код]] без применения [[JIT-компиляция|JIT-компиляции]].

== История ==
OCaml ведёт своё происхождение от ML ({{lang-en|meta language}}), который был реализован на диалекте [[Лисп]]а [[Милнер, Робин|Робином Милнером]] в [[1972 год]]у в качестве программного средства для доказательства теорем, как метаязык логики вычислимых функций (LCF, {{lang-en|logic for computable functions}}). Позднее был сделан [[компилятор]], а к [[1980 год]]у ML стал полноценной системой программирования{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=A Brief History}}.

Ги Кузино (Guy Cousineau) добавил в язык алгебраические типы данных и сопоставление с образцом и определил ML в виде [[Категориальная абстрактная машина|категориальной абстрактной машины]] (CAM). Таким образом, CAM-ML мог быть описан, верифицирован и оптимизирован, что явилось шагом вперёд для ML{{sfn|Smith|2006|p=3—4}}.

Дальнейшим развитием был созданный к [[1987 год]]у Аскандером Суарецом (Ascánder Suárez) и продолженный Пьером Вейсом (Pierre Weis) и Мичелом Мони (Michel Mauny) язык '''''Caml''''' (переигранное CAM-ML){{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=A Brief History}}{{sfn|Smith|2006|p=3—4}}.

В [[1990 год]]у Ксавье Лерой (Xavier Leroy) и Дамьен Долигез (Damien Doligez) выпустили новую реализацию, названную '''''Caml Light'''''. В этой реализации на [[Си (язык программирования)|Си]] использовался [[интерпретатор]] [[байт-код]]а и быстрый сборщик мусора. С написанием библиотек язык стал использоваться в образовании и исследовательских институтах{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=A Brief History}}{{sfn|Smith|2006|p=3—4}}.

В [[1995 год]]у увидел свет '''''Caml Special Light''''', развиваемый К. Лероем. Система программирования получила компилятор в машинные коды, что поставило эффективность исполняемого кода в один ряд с другими компилируемыми языками. В то же время была разработана [[язык модулей ML|система модулей]], идея которой была заимствована из [[Standard ML]]{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=A Brief History}}.

В современном виде OCaml появился в [[1996 год]]у, когда Дидье Реми (Didier Rémy) и Джером Вуйон (Jérôme Vouillon) реализовали для языка стройную и эффективную поддержку [[объект (программирование)|объектов]]. Эта объектная система позволяет на этапе компиляции в [[типобезопасность|типобезопасной]] манере использовать идиомы [[Объектно-ориентированное программирование|объектно-ориентированного программирования]], без свойственных [[C++]] и [[Java]] проверок [[Среда выполнения|времени выполнения]]{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=A Brief History}}.

В [[2000-е годы|2000-х годах]] язык плавно развивался, одновременно получая всё большее признание в коммерческих проектах и образовании. Среди разработанного в это время можно отметить полиморфные методы и вариантные типы, именованные и необязательные параметры, модули [[объект первого класса|первого класса]], [[Обобщённый алгебраический тип данных|обобщённые алгебраические типы данных]] (GADT). Язык стал поддерживать несколько аппаратных платформ ([[X86]], [[ARM (архитектура)|ARM]], [[SPARC]], [[PowerPC]]){{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=A Brief History}}{{sfn|Smith|2006|p=3—4}}.

== Базовая семантика ==
{{якорь|Семантика|Ядро языка|}}
<!-- Состав простых программ: определения верхнего уровня, глобальные и локальные объекты. Какие слои предусмотрены в языке (рода, типы, статическая и динамическая семантика). Что является и не является в языке значением, какие объекты языка являются [[объект первого класса|первоклассными]]. Последовательно выполняемые операторы. Объявления, привязки имён ([[:en:name binding]]), присваивания, область видимости ([[:en:scoping]]), прототипы и заголовки -->

[[Модель вычислений]] OCaml как языка функционального программирования строится на трёх основных конструкциях [[лямбда-исчисление|лямбда-исчисления]]: переменных{{переход|Переменные}}, определениях функций{{Переход|Функции}} и применении функции к аргументам{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=11—12}}.

=== Переменные ===
{{якорь|Переменные|}}
Переменная — идентификатор, значение которого связано с определённой величиной. Имена переменных начинаются со строчной буквы или подчёркивания. Привязка обычно выполняется с помощью ключевого слова <code>let</code>, как в следующем примере в интерактивной оболочке{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Variables}}:

<source lang="ocaml">
let v = 1 ;;
</source>

Переменные имеют [[область видимости]]. Например, в интерактивной оболочке переменную можно использовать в следующих за её привязкой командах. Аналогично, переменную, определённую в модуле, можно использовать после определения в данном модуле{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Variables}}.

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

<source lang="ocaml">
# let area radius =
      let pi = 3.14 in
      radius *. radius *. pi ;;
val area : float -> float = <fun>
# area 2.0 ;;
- : float = 12.56
</source>

В OCaml привязки переменных являются неизменяемыми (как в математических уравнениях), то есть, значение переменной «присваивается» только один раз (единичное присваивание). Другое дело, что внутри let-in может быть другой let-in, в котором вводится другая переменная, которая может «затенить» первую{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Variables}}.

=== Функции ===
{{якорь|Функции|}}
Для определения функций в OCaml есть несколько синтаксических конструкций.

Функции можно определить с помощью ключевого слова <code>function</code>. Выражение для функции выглядит следующим образом{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Functions}}:
<source lang="ocaml">
function x -> x + 1
</source>

В данном случае [[Анонимная функция|функция анонимная]], и её можно использовать в качестве параметров других функций или применить к некоторому аргументу, например:
<source lang="ocaml">
(function x -> x + 1) 5
</source>

Типом этой функции является <code>int -> int</code>, то есть, функция принимает [[целое (тип данных)|целое]] и возвращает целое.

Функция может иметь несколько аргументов{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=23}}:
<source lang="ocaml">
function (x, y) -> x - y
</source>

В этом примере её тип: <code>int * int -> int</code>, то есть, на входе функции — пара{{переход|Декартово произведение}}, а на выходе — целое.

Есть и другой подход представления функций нескольких аргументов — преобразование [[Арность|N-арной]] функции в N функций одного аргумента — [[каррирование]]. Следующие два вида записи функции, вычисляющей произведение целочисленных аргументов, эквивалентны{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=23}}:
<source lang="ocaml">
function x -> function y -> x * y
fun x y -> x * y
</source>

Именованные функции можно получить, связав переменную с функцией{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Functions}}. Определение именованной функции настолько частая операция, что имеет отдельную синтаксическую поддержку. Следующие три записи — эквивалентные способы определить функцию (в интерактивной оболочке):
<source lang="ocaml">
# let prod = function x -> function y -> x * y ;;
val prod : int -> int -> int = <fun>
# let prod x y = x * y ;;
val prod : int -> int -> int = <fun>
# let prod = fun x y -> x * y ;;
val prod : int -> int -> int = <fun>
</source>

Функции двух аргументов можно определить для использования [[инфиксная нотация|инфиксной записи]]{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Functions}}:
<source lang="ocaml">
# let (^^) x y = x**2.0 +. y**2.0 ;;
val ( ^^ ) : float -> float -> float = <fun>
# 2.0 ^^ 3.0 ;;
- : float = 13.
# (^^) 2.0 3.0 ;;
- : float = 13.
</source>

В этом примере определена функция <code>(^^)</code>, вычисляющая сумму квадратов двух [[Число с плавающей запятой|чисел с плавающей запятой]]. Последние два вида записи эквивалентны.

[[Рекурсия|Рекурсивные]] функции, то есть функции, ссылающиеся на своё же определение, можно задать с помощью <code>let rec</code>{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Functions}}:

<source lang="ocaml">
# let rec fac n =
    match n with 
    | 0 -> 1
    | x -> x * fac (x - 1)
  ;;
</source>

В этом же примере вычисления [[факториал]]а применено сопоставление с образцом (конструкция <code>match-with</code>).

Аргументы функции можно определить как именованные. Именованные аргументы можно указывать в любом порядке{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Functions}}:

<source lang="ocaml">
# let divmod ~x ~y = (x / y, x mod y) ;;
val divmod : x:int -> y:int -> int * int = <fun>
# divmod ~x:4 ~y:3 ;;
- : int * int = (1, 1)
# divmod ~y:3 ~x:4 ;;
- : int * int = (1, 1)
</source>

В OCaml можно опускать значения, используя уплотнённую запись ({{lang-en|label punning}}), если имя параметра и переменной совпадают{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Functions}}:

<source lang="ocaml">
# let x = 4 in
  let y = 3 in
  divmod ~x ~y ;;
- : int * int = (1, 1)
</source>

=== Выражения ===
{{якорь|Выражения|}}

Ассоциативность операций в выражениях OCaml определяется префиксом, распространяясь таким образом на операции, определённые пользователем. Знак <code>-</code> работает и как префиксная, и как инфиксная операция, причём при необходимости использовать в качестве префикса совместно с применением функции параметр нужно заключить в скобки<ref>{{Cite web |url=http://caml.inria.fr/pub/docs/manual-ocaml/expr.html |title=OCaml manual: 6.7 Expressions |access-date=2015-01-06 |archive-date=2015-01-01 |archive-url=https://web.archive.org/web/20150101034301/http://caml.inria.fr/pub/docs/manual-ocaml/expr.html |url-status=live }}</ref>.

{| class="wikitable"
|-
! Префикс операции !! Ассоциативность
|-
| <code>!</code> <code>?</code> <code>~</code> || Префикс
|-
| <code>. .( .[ .{</code> ||
|-
| применение функции, конструктора, метки, <code>assert</code>, <code>lazy</code>|| Левая
|-
| <code>- -.</code> ||Префикс
|-
| <code>** lsl lsr asr</code> || Правая
|-
| <code>* / % mod land lor lxor</code> ||Левая
|-
| <code>+ -</code> ||Левая
|-
|<code>::</code> ||Правая
|-
|<code>@ ^</code>||Правая
|-
|<code>= < > | & $ !=</code>|| Левая
|-
|<code>&</code> <code>&&</code> ||Правая
|-
|<code>or</code> <code><nowiki>||</nowiki></code> ||Правая
|-
|<code>,</code> ||
|-
|<code><-</code> <code>:=</code> ||Правая
|-
|<code>if</code> ||
|-
|<code>;</code> ||Правая
|-
|<code>let</code> <code>match</code> <code>fun</code> <code>function</code> <code>try</code> ||
|-
|}

=== Система типов ===

==== Примитивные типы ====
Язык OCaml имеет несколько [[примитивный тип|примитивных типов]]: числовые типы ([[целый тип|целый]] и числа с плавающей запятой), [[Символьный тип|символьный]], [[Строковый тип|строки символов]], [[логический тип|булевый]]{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=12}}.

'''''Целый тип''''' представляет целые числа из интервала [−2<sup>30</sup>, 2<sup>30</sup> − 1] и [−2<sup>62</sup>, 2<sup>62</sup> − 1] для 32- и 64-битных архитектур соответственно. С целыми числами можно производить обычные операции сложения, вычитания, умножения, деления, взятия [[Деление с остатком|остатка от деления]]: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>mod</code>. В случае выхода результата за допустимый интервал ошибки не происходит, а результат вычисляется по модулю границы интервала{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=13}}.

'''''Числа с плавающей запятой''''' представляются 53-битной [[Экспоненциальная запись|мантиссой]] и порядком из интервала [−1022, 1023], следуя стандарту [[IEEE 754]] для чисел с двойной точностью. В операциях эти числа нельзя смешивать с целыми. Кроме того, операции над числами с плавающей запятой синтаксически отличаются от целочисленных операций: <code>+.</code>, <code>-.</code>, <code>*.</code>, <code>/.</code>. Также имеется операция возведения в степень: <code>**</code>. Для преобразования целых чисел в числа с плавающей запятой и обратно доступны функции: float_of_int и int_of_float{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=13}}.

Для чисел с плавающей запятой имеются и другие математические функции: [[тригонометрические функции|тригонометрические]] (sin, cos, tan, asin, acos, atan), округления (ceil, floor), экспоненциальная (exp), логарифмические (log, log10), а также извлечение квадратного корня (sqrt){{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=13}}. Для числовых типов имеются и полиморфные операции сравнения{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=13}}.

'''''Символьный тип''''' — char — соответствует представлению символа с кодом от 0 до 255 (первые 128 символов совпадают с [[ASCII]]). '''''Строчный тип''''' — string — последовательность символов (максимальная длина: 2<sup>24</sup> — 6){{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=15}}. Пример с использованием функции преобразования целого к строке и операции [[Конкатенация|конкатенации]]:

<source lang="ocaml">
# "Example " ^ string_of_int(2) ;;
- : string = "Example 2"
</source>

'''''Булевый тип''''' имеет два значения: <code>true</code> (истина) и <code>false</code> (ложь). Операции над величинами булевого типа: [[Унарная операция|унарная]] <code>not</code> (отрицание), бинарные: <code>&&</code> (и), <code>||</code> (или). Бинарные операции вычисляют сначала левый аргумент, а правый — только если требуется{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=15—16}}.

Булевые значения получаются в результате сравнений: <code>=</code> (структурное равенство), <code>==</code> (тождество), <code><></code> (отрицание структурного равенства), <code>!=</code> (отрицание тождества), <code><</code>, <code>></code>, <code><=</code>, <code>>=</code>. Для примитивных типов кроме строк и чисел с плавающей точкой структурное равенство и тождество совпадают, для других типов тождественными считаются значения, располагающиеся по одному адресу в памяти, а при структурном сравнении значения проверяются покомпонентно{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=15—16}}.

Кроме того, в OCaml имеется специальный тип unit, который имеет всего одно значение — <code>()</code>{{sfn|Chailloux, Manoury, Pagano — Developing with OCaml|2007|p=15—16}}.

==== Списки ====
В OCaml [[список (структура данных)|список]] — конечная неизменяемая последовательность элементов одного типа, реализованная как односвязный список. Следующий пример демонстрирует синтаксис списка{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=List Basics}}:

<source lang="ocaml">
# ['a'; 'b'; 'c'] ;;
- : char list = ['a'; 'b'; 'c']
# 'a' :: ('b' :: ('c' :: [])) ;;
- : char list = ['a'; 'b'; 'c']
# 'a' :: 'b' :: 'c' :: [] ;;
- : char list = ['a'; 'b'; 'c']
# [] ;;
- : 'a list = []
</source>

Операция <code>::</code> позволяет построить список на основе нового элемента и хвоста старого списка. При этом «старый» список не изменяется:

<source lang="ocaml">
# let lst = [1; 2] ;;
val lst : int list = [1; 2]
# let lst1 = 0 :: lst ;;
val lst1 : int list = [0; 1; 2]
# lst ;;
- : int list = [1; 2]
# lst1 ;;
- : int list = [0; 1; 2]
</source>

===== Пример: вычисление суммы элементов списка =====
Список является одним из основных типов данных в OCaml. Следующий пример кода определяет рекурсивную (обратите внимание на ключевое слово rec) функцию, которая перебирает элементы данного списка и возвращает их сумму:

<source lang=OCaml>
let rec sum xs =
  match xs with
    | []       -> 0
    | x :: xs' -> x + sum xs'
</source>

  # sum [1;2;3;4;5];;
  - : int = 15

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

<source lang=OCaml>
let sum xs =
    List.fold_left (+) 0 xs

  # sum [1;2;3;4;5];;
  - : int = 15
</source>

==== Записи ====
[[Запись (тип данных)|Записи]] являются важным элементом в системе типов OCaml. Запись представляет собой набор хранимых вместе значений, при котором каждый элемент значения-записи доступен по своему имени — имени поля записи. Пример описания типа, связывания записи с переменной и доступ к полю записи{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Chapter 5. Records}}:

<source lang="ocaml">
# type user =
    { login       : string;
      password    : string;
      nick        : string;
    };;
# let usr = { login = "myuser"; password = "secret"; nick = "aka" ; } ;;
val usr : user = {login = "myuser"; password = "secret"; nick = "aka"}
# usr.nick ;;
- : string = "aka"
</source>

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

Как и в случае с другими типами, тип может быть параметризован. Другие возможности записей{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Chapter 5. Records}}:
* сопоставление с образцом (irrefutable)
* синтаксические уплотнение полей (field punning) записи в случае совпадения имён полей и переменных
* повторное использование полей и разрешение неоднозначности с помощью модулей
* функциональное обновление (functional update) записи
* изменяемые (mutable) поля
* fieldslib и поле записи как [[объект первого класса]]
* итераторы полей

==== Вариантный тип ====
Вариантный тип представляет данные, которые могут принимать различные формы, определяемые явно заданными метками. В следующем примере определён тип для базовых цветов{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Chapter 6. Variants}}:

<source lang="ocaml">
# type main_color = Red | Green | Blue ;;
# Blue ;; 
- : main_color = Blue
# (Red, Blue) ;;
- : main_color * main_color = (Red, Blue)
</source>

В примере выше вариантный тип используется в качестве [[Перечисляемый тип|перечислимого типа]]. В OCaml вариантный тип, тем не менее, является более богатым, так как помимо меток позволяет задавать и данные, например:

<source lang="ocaml">
# type color_scheme = RGB of int * int * int | CMYK of float * float * float * float;;
type color_scheme =
    RGB of int * int * int
  | CMYK of float * float * float * float
</source>

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

==== Объекты ====
В OCaml объекты и их типы полностью отделены от системы [[класс (программирование)|классов]]. Классы используются для построения объектов и поддержки [[наследование (программирование)|наследования]], но не являются типами объектов. Объекты имеют собственные '''''объектные типы''''' (object types), и для работы с объектами классы применять необязательно. Объекты не так часто используются в OCaml (так, система модулей является более выразительной, чем объекты, так как модули могут включать типы, а классы и объекты — нет). Основным преимуществом объектов перед записями — они не требуют объявления типов и обладают большей гибкостью благодаря полиморфизму строчных переменных ({{lang-en|row polymorphism}}). С другой стороны, преимущества объектов проявляются при использовании системы классов. В отличие от модулей, классы поддерживают позднее связывание, что позволяет ссылаться на методы объекта без статически заданной реализации и использовать открытую рекурсию (в случае с модулями можно использовать функции и функторы, но синтаксически такие описания требуют написания большего количества кода){{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Objects}}.

==== Вывод типов ====
Хотя OCaml является [[сильная и слабая типизация|языком программирования с сильной типизацией]], система [[Вывод типов|вывода типов]] ({{lang-en|type inference}}) позволяет определять тип выражения на основе имеющейся информации о его компонентах. В следующем примере функции проверки числа на чётность не указано ни одной декларации типа, и тем не менее у компилятора языка есть полная информация о типе функции{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Functions and Type Inference}}:

<source lang="ocaml">
# let odd x = x mod 2 <> 0 ;;
val odd : int -> bool = <fun>
</source>

=== Императивное программирование и функции с побочными эффектами ===
Помимо функциональных, язык содержит средства [[Императивное программирование|императивного программирования]]: функции с [[побочный эффект (программирование)|побочными эффектами]], изменяемые (mutable) данные, императивные синтаксические конструкции, в частности, явные [[цикл (программирование)|циклы]] <code>while</code> и <code>for</code>{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Imperative Programming}}.

Следующий пример напечатает на [[Стандартные потоки|стандартном выводе]] (это — побочный эффект функции printf) 11 строк:
<source lang="ocaml">
for i = 0 to 10 do 
  Printf.printf "i =%d\n" i
done;;
</source>

В следующем (довольно искусственном) примере элементы массива на месте увеличиваются на единицу в цикле с предусловием. Для индекса массива используется ссылка (ref), которая инкрементируется в теле цикла:
<source lang="ocaml">
# let incr_ar ar =
    let i = ref 0 in
    while !i < Array.length ar do
      ar.(!i) <- ar.(!i) + 1;
      incr i
  done ;;
val incr_ar : int array -> unit = <fun>
# let nums = [|1;2;3;4;5|];;
val nums : int array = [|1; 2; 3; 4; 5|]
# incr_ar nums;;
- : unit = ()
# nums;;
- : int array = [|2; 3; 4; 5; 6|]
</source>

Побочные эффекты позволяют оптимизировать вычисления, в особенности, когда речь идёт о значительных преобразованиях на больших массивах данных. Также с их помощью реализуются [[ленивые вычисления]] и [[мемоизация]]{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Imperative Programming}}.

== Крупномасштабное программирование ==
{{якорь|Крупномасштабное программирование|programming-in-large|programming in large|}}

=== Модульность ===
{{якорь|Модули|Пакеты|Модули и пакеты|Модульность|Система модулей|}}
{{main|Язык модулей ML}}
OCaml можно представить себе как состоящий из двух языков: язык ядра со значениями и типами и язык модулей и их [[Язык модулей ML#Сигнатура|сигнатур]]. Эти языки образуют два слоя в том смысле, что модули могут содержать типы и значения, а обычные значения не могут содержать модулей и модулей-типов. Тем не менее, OCaml предлагает механизм модулей [[объект первого класса|первого класса]], которые могут быть значениями и при необходимости преобразуются в обычные модули и обратно{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=First-Class Modules}}.

=== Функторы ===
{{main|Функтор (модуль)}}
Система модулей OCaml не ограничивается модульной организацией кода и интерфейсами. Одними из важных инструментов [[обобщённое программирование|обобщённого программирования]] являются '''''функторы'''''. Упрощённо говоря, функторы являются функцией из модуля в модули, что позволяет реализовать следующие механизмы{{sfn|Minsky, Madhavapeddy, Hickey|2013|loc=Functors}}:
* [[Внедрение зависимости]] ({{lang-en|dependency injection}})
* Авторасширение модулей ({{lang-en|autoextension of modules}})
* Создание экземпляра ({{lang-en|instantiation}}) модуля с некоторым состоянием

== Примеры программ ==

=== Запуск интерпретатора OCaml ===
Для запуска интерпретатора языка OCaml необходимо в консоли ввести следующую команду:
<source lang="bash">
$ ocaml
       OCaml version 4.08.1
#
</source>

Вычисления можно производить в интерактивном режиме, например:

<source lang="ocaml">
# 1 + 2 * 3;;
- : int = 7
</source>

=== Hello world ===
Следующая программа «hello.ml»:

<source lang="ocaml">
print_endline "Hello World!";;
</source>

может быть скомпилирована либо в [[байт-код]]:

<source lang="bash">
$ ocamlc hello.ml -o hello
</source>

либо в оптимизированный [[машинный код]]:

<source lang="bash">
$ ocamlopt hello.ml -o hello
</source>

и запущена:

<source lang="bash">
$ ./hello
Hello World!
$
</source>

=== Быстрая сортировка ===
В следующем примере приведён алгоритм [[Быстрая сортировка|быстрой сортировки]], который сортирует список в порядке возрастания:

<source lang="OCaml">
let rec qsort = function
   | [] -> []
   | pivot :: rest ->
       let is_less x = x < pivot in
       let left, right = List.partition is_less rest in
       qsort left @ [pivot] @ qsort right
</source>

=== Последовательность Фибоначчи ===
<source lang = OCaml>
let rec fib_aux n a b =
  match n with
  | 0 -> a
  | _ -> fib_aux (n - 1) (a + b) a
let fib n = fib_aux n 0 1
</source>

== См. также ==
* [[MLton]]

== Примечания ==
{{примечания}}

== Литература ==
'''[https://web.archive.org/web/20120915155956/http://www.ocaml-lang.org/books.html Список книг, доступных онлайн]'''
* {{книга
 | автор         = Minsky, Y. and Madhavapeddy, A. and Hickey, J.
 | заглавие      = Real World OCaml: Functional Programming for the Masses
 | издательство  = O'Reilly Media
 | год           = 2013
 | allpages      = 510
 | isbn          = 9781449324766
 | ref           = Minsky, Madhavapeddy, Hickey
}}
** Перевод на русский язык: {{книга
| автор = Мински, Ярон; Мадхавапедди, Анил; Хикки, Джейсон
| заглавие = Программирование на языке OCaml
| оригинал = Real World OCaml: Functional Programming for the Masses
| издание =
| серия = Функциональное программирование
| место =
| издательство = ДМК
| год = 2014
| страниц = 536
| isbn = 978-5-97060-102-0
| ссылка =
| ref = Мински
}}
{{Hider|
| title = Важно: некорректность перевода в русском издании
| frame-style =
| title-style = text-align: left;
| content-style = text-align: left;
| hidden = true
| content =
'''''Примечание''''' — в книге используется перевод термина «{{lang-en2|first-class function}}» как «{{lang-ru2|функция первого порядка}}». Но следует иметь в виду, что в многочисленных англоязычных источниках (по семантике языков вообще и по [[ML]] и [[Система типов Хиндли — Милнера|Хиндли-Милнеру]] в частности) концептуально различается четыре понятия:
* first-class,
* second-class,
* first-order,
* high-order,
причём «{{lang-en2|first-class}}» — это «''лучше''», чем «{{lang-en2|second-class}}» (шире по возможностям, ближе к теории и выше по порогу вхождения ([http://www.itu.dk/courses/BPRD/E2009/fundamental-1967.pdf C. Strachey — ''Fundamental Concepts in Programming Languages''])), но «{{lang-en2|first-order}}» примитивнее, чем «{{lang-en2|high-order}}». В частности, [[Язык модулей ML#Расширения|расширение языка модулей ML]] до уровня {{nowrap|«{{lang-en2|first-class high-order}}»}} представляет собой существенно большую проблематику для исследователей, чем его расширение только до «{{lang-en2|first-class}}» или только до «{{lang-en2|high-order}}» ({{cite web
| title = Functors and runtime vs compile time
| author = Rossberg A.
| date = 
| lang = 
| url = http://objectmix.com/302412-functors-runtime-vs-compile-time.html
| ref = Rossberg - Functors and runtime vs compile time
| access-date = 2015-06-25
| archive-date = 2015-06-26
| archive-url = https://web.archive.org/web/20150626112928/http://objectmix.com/302412-functors-runtime-vs-compile-time.html
| url-status = dead
}}).}}
* {{книга
 |автор         = Joshua B. Smith
 |заглавие      = Practical OCaml
 |издательство  = Apress
 |год           = 2006
 |страниц       = 488
 |isbn          = 9781590596203
 |ref = Smith
}}
* {{статья|ссылка=http://queue.acm.org/detail.cfm?id=2038036|автор=Yaron Minsky|заглавие=OCaml for the Masses|издание=ACM Queue: Programming Languages|год=2011|том=9|номер=9|ref=Minsky}}
* {{книга
|автор = Chailloux, Manoury, Pagano
|заглавие = Developing Applications With Objective Caml
|год = 2007
|язык =en
|isbn =
|ссылка =
|ref = Chailloux, Manoury, Pagano — Developing with OCaml
}}
* {{статья|заглавие=Введение в Функциональное Программирование|автор=Харрисон Дж.|оригинал=http://www.cl.cam.ac.uk/Teaching/Lectures/funprog-jrh-1996/|издание=|издательство=|тип=|месяц=|число=|том=|номер=|страницы=|год=1997|язык=|ссылка=http://funprog-ru.github.io/|ref=|url-status=dead|issn=|archive-url=https://web.archive.org/web/20150111005204/http://dspace.nsu.ru:8080/jspui/bitstream/nsu/88/1/Harrison.pdf|archive-date=2015-01-11}}

== Ссылки ==
* [http://ocaml.org Официальный сайт языка OCaml]{{ref|en}}
* [http://www.ocamlcore.org/ Сайт OCaml Community]{{ref|en}}
* [https://ocamlverse.github.io/ Ocamlverse]{{ref|en}} Documenting everything about OCaml
* [http://www.camlcity.org/ Сайт Gerd Stolpmann’a, посвящённый OCaml]{{ref|en}}
* [http://ocaml.spb.ru/ Перевод документации на русский язык] (для OCaml v. 3)
* Emmanuel Chailloux, Pascal Manoury and Bruno Pagano [http://caml.inria.fr/pub/docs/oreilly-book/ Developing Applications With Objective Caml]{{ref|en}}
** [http://shamil.free.fr/comp/ocaml/ Перевод на русский язык первых 11 глав книги O’Reilly DAOC]


[[Категория:Объектно-ориентированные языки программирования]]
[[Категория:Языки программирования семейства ML]]
[[Категория:Свободные компиляторы и интерпретаторы]]
[[Категория:Языки программирования с расширяемым синтаксисом]]