Выражения

За исключением let -выражений эти трансляции сохраняют и статическую, и динамическую семантику. Свободные переменные и конструкторы, используемые в этих трансляциях, всегда ссылаются на сущности, определенные в Prelude. Например, "concatMap", используемая в трансляции описания списка (раздел 3.11), обозначает concatMap, определенную в Prelude, невзирая на то, находится ли идентификатор "concatMap" в области видимости, где используется описание списка, и (если находится в области видимости) к чему он привязан.

В синтаксисе, который следует далее, есть некоторые семейства нетерминалов, индексированные уровнями приоритета (записанными как верхний индекс). Аналогично, нетерминалы op (оператор), varop (оператор-переменной) и conop (оператор-конструктора) могут иметь двойной индекс: букву l, r или n соответственно для левоассоциативности, правоассоциативности или отсутствия ассоциативности и уровень приоритета. Переменная уровня приоритета i изменяется в пределах от 0 до 9, переменная ассоциативности a изменяется в диапазоне {l, r, n}. Например,

на самом деле обозначает 30 правил вывода с 10 подстановками для i и 3 для a.

Перевод:

Неоднозначность выражений, включая инфиксные операторы, разрешается с помощью ассоциативности и приоритета оператора (см. раздел 4.4.2). Следующие друг за другом операторы без скобок, имеющие один и тот же приоритет, должны быть оба либо левоассоциативными, либо правоассоциативными, во избежание синтаксической ошибки. Для заданного выражения без скобок "x qop(a,i) y qop(b,j) z", где qop - оператор, часть "x qop(a,i) y" или "y qop(b,j) z" следует взять в скобки, когда i=j, за исключением a=b=l или a=b=r.

Отрицание является единственным префиксным оператором в Haskell , он имеет тот же приоритет, что и инфиксный оператор -, определенный в Prelude (см. раздел 4.4.2).

Грамматика является неоднозначной по отношению к пространству лямбда-абстракций, let-выражений и условных выражений. Неоднозначность разрешается с помощью мета-правила, согласно которому каждая из этих конструкций рассматривается слева направо насколько это возможно.

Примеры интерпретации при разборе показаны ниже.

Замечание относительно разбора. Выражения, которые затрагивают взаимодействие ассоциативности и приоритетов с применением мета-правила для let/лямбда, могут оказаться трудными для разбора. Например, выражение

let x = True in x == x == True

не может означать

let x = True in (x == x == True)

потому что (==) является неассоциативным оператором, поэтому выражение должно быть интерпретировано таким образом:

(let x = True in (x == x)) == True

Тем не менее, реализации могут прекрасно обойтись дополнительным проходом после завершения разбора, чтобы обработать ассоциативность и приоритеты операторов, поэтому они могут спокойно передать предыдущий неправильный разбор. Мы советуем программистам избегать использования конструкций, чей разбор затрагивает взаимодействие (отсутствия) ассоциативности с применением мета-правила для let/лямбда.

Ради ясности остальная часть этого раздела описывает синтаксис выражений без указания их приоритетов.

3.1 Ошибки

Ошибки во время вычисления выражений, обозначаемые как _|_, в программе на Haskell не отличимы от незавершенного вычисления. Поскольку Haskell является языком с нестрогой типизацией данных, все типы Haskell включают _|_. Другими словами, значение любого типа может быть связано с вычислением, которое будет завершено, когда потребуется результат вычисления, и завершится с ошибкой. При своем вычислении ошибки вызывают немедленное завершение программы и не могут быть отловлены пользователем. Prelude содержит две функции, которые сразу вызывают такие ошибки:

error     :: String -> a
undefined :: a

Вызов функции error завершает выполнение программы и возвращает в операционную систему соответствующий признак ошибки. Он также должен вывести на экран строку некоторым, зависящим от системы, способом. Когда используется функция undefined, сообщение об ошибке создается компилятором.

Трансляции выражений Haskell используют error и undefined для явного указания мест, где могли возникнуть ошибки времени выполнения. Реальное поведение программы в случае возникновения ошибки зависит от реализации. Сообщения, передаваемые в функцию error при этих трансляциях, являются лишь указаниями, реализации могут выбирать между отображением большей или меньшей информации в случае возникновения ошибки.

3.2 Переменные, конструкторы, операторы и литералы

Перевод:

Для поддержки инфиксной записи в Haskell используется специальный синтаксис. Оператор - это функция, которая может быть применена, используя инфиксный синтаксис (раздел 3.4), или частично применена, используя сечения (раздел 3.5).

Оператор представляет собой символ оператора, например, + или $$, или обычный идентификатор, заключенный в обратные кавычки, например, 'op'. Вместо префиксной записи op x y можно использовать инфиксную запись x 'op' y. Если ассоциативность и приоритет для 'op' не заданы, то по умолчанию используется наивысший приоритет и левоассоциативность (см. раздел 4.4.2).

Наоборот, символ оператора может быть преобразован в обычный идентификатор, если записать его в круглых скобках. Например, (+) x y эквивалентно x + y, а foldr (*) 1 xs эквивалентно foldr (\x y -> x*y) 1 xs.

Для обозначения некоторых конструкторов встроенных типов используется специальный синтаксис, как это видно из грамматики для gcon (общего-конструктора) и literal (литерала). Они описаны в разделе 6.1.

Целый литерал представляет собой применение функции fromInteger к соответствующему значению типа Integer. Аналогично, литерал с плавающей точкой обозначает применение функции fromRational к значению типа Rational (то есть Ratio Integer ).

3.3 Производные функции и лямбда-абстракции

Перевод:

Применение функции записывается в виде e1 e2. Применение левоассоциативно, поэтому в (f x) y скобки можно опустить. Поскольку e1 может являться конструктором данных, возможно частичное применение конструкторов данных.

Лямбда-абстракции записываются в виде \ p1 ... pn -> e, где pi - образцы. Выражение вида \x:xs -> x синтаксически неправильно, его можно правильно записать в виде \(x:xs) -> ;x.

Набор образцов должен быть линейным: ни одна переменная не должна появляться в наборе более одного раза.

Используя эту трансляцию в комбинации с с семантикой case-выражений и сопоставлений с образцом, описанной в разделе 3.17.3, получим: если сопоставление с образцом завершится неудачно, то результатом будет _|_.

3.4 Применение операторов

Перевод:

Форма e1 qop e2 представляет собой инфиксное применение бинарного оператора qop к выражениям e1 и e2.

Специальная форма -e обозначает префиксное отрицание, единственный префиксный оператор в Haskell , и является синтаксической записью отрицания (e). Бинарный оператор - необязательно ссылается на определение - в Prelude, он может быть переопределен системой модуля. Тем не менее, унарный оператор - будет всегда ссылаться на функцию negate, определенную в Prelude. Нет никакой связи между локальным значением оператора - и унарным отрицанием.

Префиксный оператор отрицания имеет тот же приоритет, что и инфиксный оператор -, определенный в Prelude (см. таблицу в п.4.4.3). Поскольку e1-e2 при разборе интерпретируется как инфиксное применение бинарного оператора -, для альтернативной интерпретации нужно писать e1(-e2). Аналогично, (-) является синтаксической записью (\ x y -> x-y), как и любой инфиксный оператор, и не обозначает (\ x -> -x) - для этого нужно использовать negate.

3.5 Сечения

Перевод:

Сечения записываются в виде ( op e ) или ( e op ), где op - бинарный оператор, а e - выражение. Сечения представляют собой удобный синтаксис для записи частичного применения бинарных операторов.

Синтаксические правила приоритетов применяются к сечениям следующим образом. (op e) допустимо, если и только если (x op e) при разборе интерпретируется так же, как и (x op (e)) ; аналогично для (e op). Например, (*a+b) синтаксически недопустимо, но (+a*b) и (*(a+b)) допустимы. Поскольку оператор (+) левоассоциативен, (a+b+) синтаксически правильно, а (+a+b) - нет, его можно правильно записать в виде (+(a+b)). В качестве другого примера рассмотрим выражение

(let n = 10 in n +)

которое является недопустимым в соответствии с мета-правилом для let/лямбда (раздел 3). Выражение

(let n = 10 in n + x)

при разборе интерпретируется как

(let n = 10 in (n + x))

вместо

((let n = 10 in n) + x)

Поскольку - интерпретируется в грамматике специальным образом, (- exp) является не сечением, а применением префиксного оператора отрицания, в соответствии с описанием в предыдущем разделе. Тем не менее, имеется функция subtract, определенная в Prelude таким образом, что (subtract exp) эквивалентно недопустимому ранее сечению. Для той же цели может служить выражение (+ (- exp)).

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

Перевод:

Условное выражение имеет вид if e1 then e2 else e3 и возвращает: значение e2 - если значение e1 равно True, e3 - если e1 равно False, и _|_ - иначе.

3.7 Списки

Перевод:

Списки записываются в виде [e1, ..., ek], где k >= 1. Конструктором списка является :, пустой список обозначается []. Стандартные операции над списками описаны в Prelude (см. раздел 6.1.3 и лекции 8, особенно раздел 8.1).

Конструктор : предназначен исключительно для построения списка; как и [], он является обоснованной частью синтаксиса языка и не может быть скрыт или переопределен. Он представляет собой правоассоциативный оператор с уровнем приоритета 5 (раздел 4.4.2).

3.8 Кортежи

Перевод:

Кортежи записываются в виде (e1, ..., ek) и могут быть произвольной длины k >= 2. Конструктор для кортежа размера n обозначается (,...,), где n-1 запятых. Таким образом, (a,b,c) и (,,) a b c обозначают одно и то же значение. Стандартные операции над кортежами описаны в Prelude (см. раздел 6.1.4 и лекцию 8).

3.9 Единичные выражения и выражения в скобках

Перевод:

Выражение вида (e) представляет собой просто выражение в скобках и эквивалентно e. Единичное выражение () имеет тип () (см. раздел 4.1.2). Этот единственный член указанного типа, отличный от _|_, может рассматриваться как "кортеж нулевого размера" (см. раздел 6.1.5).

3.10 Арифметические последовательности

Перевод:

Арифметическая последовательность [e1, e2 .. e3] обозначает список значений типа t, где каждое из выражений ei имеет тип t, и t является экземпляром класса Enum.

Семантика арифметических последовательностей поэтому полностью зависит от объявления экземпляра для типа t. Для получения более детальной информации о том, какие типы Prelude являются подтипами Enum и какова их семантика, смотрите рздел 6.3.4.

3.11 Описание списка

Перевод:

Описание списка имеет вид [ e | q1, ..., qn ], n>=1, где квалификаторы qi являются

Такое описание списка возвращает список элементов, порожденный путем вычисления e в последовательных окружениях, созданных вложенным вычислением вглубину генераторов в списке квалификаторов. Связывание имен переменных происходит согласно правилам обычного сопоставления с образцом (см. раздел 3.17), и если сопоставление завершится неудачей, то соответствующий элемент списка будет просто пропущен. Таким образом,

[ x |  xs   <- [ [(1,2),(3,4)], [(5,4),(3,2)] ], 
      (3,x) <- xs ]

порождает список [4,2]. Если квалификатор является стражем, то, для того чтобы предшествующее сопоставление с образцом завершилось успешно, необходимо, чтобы значение квалификатора равнялось True. Как обычно, связывания имен в описаниях списков могут скрыть связывания имен во внешних областях видимости, например,

[ x | x <- x, x <- x ]= [ z | y <- x, z <- y]

Как показывает трансляция описаний списков, переменные, связанные с помощью let, имеют полностью полиморфные типы, тогда как переменные, определенные с помощью >-, связаны лямбда-выражением и поэтому мономорфны (см. раздел 4.5.4).

3.12 Let-выражения

Перевод:

Let-выражения имеют общий вид let { d1 ; ... ; dn } in e и вводят вложенный, лексически ограниченный, взаимно рекурсивный список объявлений (в других языках let часто называют letrec ). Областью видимости объявлений является выражение e и правая часть объявлений. Объявления описаны в лекции 4. Сопоставление и связывание образцов выполняется лениво, неявная - делает эти образцы неопровержимыми. Например,

let (x,y) = undefined in e

не вызовет ошибку времени выполнения до тех пор, пока x или y не будут вычислены.

let {p1=e1;  ... ; pn=e1} in e0  = let (~p1, ... ,~pn) = (e1, ... ,en) in e0  
let p = e1  in  e0  = case e1 of ~p -> e0

let p = e1  in  e0  = let p = fix ( \ ~p -> e1) in e0

3.13 Case-выражения

Перевод:

Case-выражение имеет общий вид

case e of { p1 match1 ; ... ; pn matchn }

где каждый matchi имеет общий вид

| gi1-> ei1
...
| gimi-> eimi
where declsi

(Заметьте, что в синтаксическом правиле для gd "|" является терминальным символом, а не синтаксическим мета-символом для указания альтернатив.) Каждая альтернатива pi matchi состоит из образца pi и его сопоставлений matchi. Каждое сопоставление, в свою очередь, состоит из последовательности пар стражей gij и тел eij (выражений), за которыми следуют необязательные связывания (declsi), чья область видимости распространяется над всеми стражами и выражениями альтернативы. Альтернатива вида

pat -> exp where decls

интерпретируется как краткая запись для

pat | True-> exp
where decls

Case-выражение должно иметь по крайней мере одну альтернативу, и каждая альтернатива должна иметь по крайней мере одно тело. Каждое тело должно иметь один и тот же тип, и все выражение должно быть того же типа.

Вычисление case-выражения выполняется посредством сопоставления выражения e отдельным альтернативам. Альтернативы проверяются последовательно, сверху вниз. Если e соответствует образцу в альтернативе, выполняется связывание переменных, сначала указанных в образце, а затем - с помощью declsi в операторе where, связанном с этой альтернативой. Если значение одного из вычисляемых стражей окажется True, в том же окружении, что и страж, будет вычислена соответствующая правая часть. Если значения всех стражей окажутся False, процесс сопоставления с образцом будет возобновлен со следующей альтернативы. Если не удастся сопоставить ни один образец, результатом будет _|_. Сопоставление с образцом описано в разделе 3.17, а формальная семантика case-выражений - в разделе 3.17.3.

Замечание о разборе. Выражение

case x of { (a,_) | let b = not a in b :: Bool -> a }

нелегко правильно интерпретировать при разборе. Оно имеет единственную однозначную интерпретацию, а именно:

case x of { (a,_) | (let b = not a in b :: Bool) -> a }

Тем не менее, выражение Bool -> a является синтаксически правильным типом, и синтаксические анализаторы с ограниченным предварительным просмотром могут выбрать этот неправильный вариант, и тогда программа будет признана недопустимой. Поэтому мы советуем программистам избегать использования стражей, которые заканчиваются указанием сигнатуры типа, именно поэтому gd содержит exp0, а не не exp.

3.14 Do-выражения

Перевод:

Do-выражения предоставляют более удобный синтаксис для монадического программирования. Оно позволяет записать такое выражение

putStr "x: "    >> 
  getLine         >>= \l ->
  return (words l)

в более традиционном виде:

do putStr "x: "
     l <- getLine
     return (words l)

Как показано в трансляции do, переменные, связанные let, имеют полностью полиморфные типы, тогда как те переменные, которые определены с помощью <-, являются связанными лямбда-выражением и поэтому являются мономорфными.

3.15 Типы данных с именованными полями

Объявление типа данных может содержать необязательные определения имен полей (см. раздел 4.2.1). Эти имена полей можно использовать для создания, извлечения и обновления полей способом, который не зависит от всей структуры типа данных.

Различные типы данных не могут совместно использовать общие имена полей в одной области видимости. Имя поля можно использовать не более одного раза в конструкторе. В пределах типа данных, тем не менее, имя поля можно использовать в более чем одном конструкторе, при условии, что поле имеет один и тот же тип во всех конструкторах. Для того чтобы проиллюстрировать последнее замечание, рассмотрим:

data S = S1 { x :: Int } | S2 { x :: Int }   - OK
  data T = T1 { y :: Int } | T2 { y :: Bool }  - ПЛОХО

Здесь S является допустимым типом данных, а T - нет, потому что в последнем случае для y указан другой тип, противоречащий указанному ранее.

3.15.1 Извлечение полей

Перевод:

Имена полей используются в качестве селекторной функции. Когда имя поля используется в качестве переменной, оно действует как функция, которая извлекает поле из объекта. Селекторы являются связываниями верхнего уровня, и поэтому они могут быть перекрыты локальными переменными, но не могут конфликтовать с другими связываниями верхнего уровня с тем же именем. Это сокрытие затрагивает только селекторные функции, при создании записей (раздел 3.15.2) и их обновлении (раздел 3.15.3) имена полей не могут быть спутаны с обычными переменными.

3.15.2 Создание типов данных с использованием имен полей

Перевод:

Конструктор с именованными полями может использоваться для создания значения, в котором компоненты задаются именем, а не позицией. В отличие от фигурных скобок, используемых в списках объявлений, здесь присутствие фигурных скобок не зависит от размещения текста, символы { и } должны использоваться явно. (То же самое относится к обновлению полей и образцам полей.) Создание объектов с использованием имен полей подчинено следующим ограничениям:

Выражение F {}, где F - конструктор данных, является допустимым независимо от того, было или нет F объявлено с использованием синтаксиса записи (при условии, что F не имеет обязательных полей, см. пункт третий в приведенном выше списке); оно обозначает F _|_1 ... _|_n, где n - число аргументов F.

3.15.3 Обновления с использованием имен полей

Перевод:

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

Вот некоторые примеры, использующие именованные поля:

data T    = C1 {f1,f2 :: Int}
          | C2 {f1 :: Int,
                f3,f4 :: Char}

Поле f1 является общим для обоих конструкторов в T. Этот пример транслирует выражения, использующие конструкторы, записываемые с именами полей, в эквивалентные выражения, использующие те же самые конструкторы без имен полей. Если не будет единого конструктора, который определяет набор имен полей в обновлении, такого как x {f2 = 1, f3 = 'x'}, произойдет ошибка компиляции.

3.16 Сигнатуры типов выражений

Перевод:

Сигнатуры типов выражений имеют вид e :: t, где e - выражение, а t - тип (раздел 4.1.2); они используются для явного указания типа выражения, в частности, для того чтобы разрешить неоднозначность типов из-за перегрузки (см. раздел 4.3.4). Значением выражения является значение exp. Как и с обычными сигнатурами типов (см. раздел 4.4.1), объявленный тип может быть более частным, чем основной тип, выводимый из exp, но будет ошибкой указать тип, который окажется более общим или не сопоставимым с основным типом.

3.17 Сопоставление с образцом

Образцы появляются в лямбда-абстракциях, определениях функций, связываниях с образцом, описаниях списков, do-выражениях и case-выражениях. Тем не менее, первые пять из них в конечном счете транслируются в case-выражения, поэтому достаточно ограничиться определением семантики сопоставления с образцом для case-выражений.

3.17.1 Образцы

Образцы имеют следующий синтаксис:

Перевод:

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

Все образцы должны быть линейными : ни одна переменная не может появляться более одного раза. Например, следующее определение недопустимо:

f (x,x) = x - ЗАПРЕЩЕНО; x дважды используется в образце

Образцы вида var@pat называются "такими как" - образцами, и позволяют использовать var в качестве имени для значения, сопоставляемого pat. Например,

case e of { xs@(x:rest) -> if x==0 then rest else xs }

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

let { xs = e } in
  case xs of { (x:rest) -> if x==0 then rest else xs }

Образцы вида _ обозначают группы любых символов и полезны, когда некоторая часть образца не используется в правой части. Это как если бы идентификатор, не используемый где-либо в другом месте, был помещен на свое место. Например,

case e of { [x,_,_]  ->  if x==0 then True else False }

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

case e of { [x,y,z]  ->  if x==0 then True else False }