16. Известные ошибки и неточности

16.1.1.1. Лексическая синтаксис

• Некоторые лексические правила относительно квалифицированных идентификаторов немного отличаются в GHC по сравнению с отчётом Haskell. Когда у вас есть ⟨module⟩.⟨reservedop⟩, например M.\, GHC будет интерпретировать его как единый квалифицированный оператор вместо двух лексем M и .\.
• forall всегда является зарезервированным ключевым словом. Это противоречит отчёту Haskell, который допускает использование переменных и типов переменных с именем forall. Обратите внимание, что это не означает, что GHC всегда включает расширение ExplicitForAll. Даже без включённого расширения зарезервирование forall в качестве ключевого слова имеет значение. Например, GHC не будет парсить подпись типа foo :: forall x.
• Оператор (!), когда он написан в префиксной форме (предваряемый пробелом и не последуемый пробелом, как в f !x = ...), интерпретируется как шаблон bang, в отличие от отчёта Haskell, который предписывает рассматривать ! как оператор независимо от окружающих пробелов. Обратите внимание, что это не означает, что GHC всегда включает BangPatterns. Без расширения GHC выдаст ошибку разбора f !x, попросив включить расширение.

• Неразрушаемые шаблоны должны быть написаны в префиксной форме:

  f ~a ~b = ...    -- accepted by both GHC and the Haskell Report
  f ~ a ~ b = ...  -- accepted by the Haskell Report but not GHC
  

  Когда они написаны в не-префиксной форме, (~) GHC рассматривает как обычный инфиксный оператор.

  См. Предложение GHC №229 для точных правил.

• Комментарии строгости в объявлениях данных должны быть написаны в префиксной форме:

  data T = MkT !Int   -- accepted by both GHC and the Haskell Report
  data T = MkT ! Int  -- accepted by the Haskell Report but not GHC
  

  См. Предложение GHC №229 для точных правил.

• Шаблоны «как» не должны быть окружены пробелами с обеих сторон:

  f p@(x, y, z) = ...    -- accepted by both GHC and the Haskell Report
  
  -- accepted by the Haskell Report but not GHC:
  f p @ (x, y, z) = ...
  f p @(x, y, z) = ...
  f p@ (x, y, z) = ...
  

  Когда они окружены пробелами с обеих сторон, (@) GHC рассматривает как обычный инфиксный оператор.

  Когда предваряются, но не последуют пробелами, (@) рассматривается как видимое применение типа.

  См. Предложение GHC №229 для точных правил.

• Отчёт Haskell допускает любые десятичные числа Unicode в десятичных литералах. Однако GHC принимает только ASCII-цифры:

  ascDigit    →   0 | 1 | … | 9
  decimal     →   ascDigit {ascDigit}
  

• GHC более лоялен в выборе допустимых символов в идентификаторах. Другие символы Unicode рассматриваются как строчные буквы, поэтому идентификаторы переменных могут начинаться с них. Класс цифр включает все числа Unicode вместо только десятичных. Модификаторы и знаки без пробелов могут появляться в конце идентификаторов:

  uniSmall    →   any Unicode Lowercase Letter or Other Letter
  uniDigit    →   any Unicode Decimal Number, Letter Number or Other Number
  
  uniIdchar   →   any Unicode Modifier Letter or Non-Spacing Mark
  idchar      →   small | large | digit | uniIdchar | '
  
  varid       →   small {idchar} ⟨reservedid⟩
  conid       →   large {idchar}
  

• GHC допускает избыточные скобки вокруг имени функции в части funlhs объявлений. То есть GHC успешно распознает объявление вроде ((f)) x = <rhs> для любого количества скобок вокруг f.

16.1.1.2. Контекстно-свободный синтаксис

• В режиме Haskell 98 (но не в режиме Haskell 2010) GHC немного менее строг к правилу выравнивания при использовании в do выражениях. В частности, ограничение, что «вложенный контекст должен быть отступающим дальше вправо, чем окружающий контекст», ослабляется, чтобы позволить вложенному контексту быть на одном уровне с окружающим контекстом, если вложенный контекст является выражением do.

  Например, следующий код, в котором контекст do вложен в контекст case, а оператор feed animal отступает на такое же значение, как и альтернатива case, принимается GHC:

  main = case animal of
           Wombat -> do
           feed animal
  

  Но этот код с обратным вложением не принимается:

  main = do
    case animal of
    Wombat -> feed animal
  

  Это поведение контролируется расширением NondecreasingIndentation.

NondecreasingIndentation

Since:

7.2.1

Status:

Включено в Haskell98

Разрешить вложенным контекстам иметь тот же уровень отступа, что и окружающий контекст.

• GHC не выполняет разрешение фиктивности в выражениях во время разбора, как требуется в Haskell 98 (но не в Haskell 2010). Например, согласно отчёту Haskell 98, следующее выражение законно:

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

  и разбирается как:

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

  потому что, согласно отчёту, выражение let «распространяется как можно дальше вправо». Поскольку оно не может распространиться дальше второй знака равенства без возникновения ошибки разбора (== не является фиктивным), выражение let должно завершиться там. GHC просто поглощает всё выражение, разбирая его так:

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

16.1.1.3. Выражения и шаблоны

По умолчанию GHC делает некоторые программы немного более определёнными, чем они должны быть. Например, рассмотрите

f :: [a] -> b -> b
f [] = error "urk"
f (x:xs) = \v -> v

main = print (f [] `seq` True)

Это должно вызвать error, но на самом деле выводит True. Причина: GHC расширяет f до

f :: [a] -> b -> b
f []     v = error "urk"
f (x:xs) v = v

Для большинства программ это достаточно улучшает эффективность, чтобы быть включённым, и плохо только в редких случаях. Чтобы подавить эту оптимизацию, используйте -fpedantic-bottoms.

16.1.1.4. Шаблоны с ошибками

После предложения MonadFail Proposal (MFP), блоки do-нотации, содержащие шаблон с ошибками, требуют ограничения MonadFail.

Например

mayFail :: (MonadIO m) => m ()
mayFail = do
  (Just value) <- fetchData
  putStrLn value

Выдаст предупреждение

• Could not deduce (MonadFail m)
    arising from a do statement
    with the failable pattern ‘(Just x)’
  from the context: MonadIO m
    bound by the type signature for:
               mayFail :: forall (m :: * -> *). MonadIO m => m ()

И действительно, так как класс Monad больше не имеет метода fail, нам нужно явно добавить (MonadFail m) к ограничениям функции.

16.1.1.5. Проверка типов рекурсивных групп связываний

Отчёт Haskell определяет, что группа связываний (на верхнем уровне или в let или where) должна быть отсортирована в сильносвязанные компоненты, а затем проверка типов выполняется в порядке зависимости (Отчёт Haskell, раздел 4.5.1). При проверке типов каждой группы все связующие этой группы, имеющие явную сигнатуру типа, помещаются в среду типов со специфицированным полиморфным типом, а все остальные — мономорфные до обобщения группы (Отчёт Haskell, раздел 4.5.2).

Следуя предложению Марка Джонса в его работе Typing Haskell in Haskell, GHC реализует более общую схему. В GHC анализ зависимостей игнорирует ссылки на переменные, которые имеют явную сигнатуру типа. В результате этого уточнённого анализа зависимостей группы зависимостей становятся меньше, и больше связываний будут проверены на типы. Например, рассмотрим:

f :: Eq a => a -> Bool
f x = (x == x) || g True || g "Yes"

g y = (y <= y) || f True

Это отклоняется Haskell 98, но в схеме Джонса определение g проверяется на тип в первую очередь, отдельно от определения f, потому что ссылка на f в правой части g игнорируется анализом зависимостей. Затем тип g обобщается, чтобы получить

g :: Ord a => a -> Bool

Теперь определение f проверяется на тип, с этим типом для g в среде типов.

Тот же усовершенствованный анализ зависимостей также позволяет сигнатурам типов взаимно рекурсивных функций иметь разные контексты, что незаконно в Haskell 98 (Раздел 4.5.2, последнее предложение). GHC настаивает только на том, чтобы сигнатуры типов уточнённой группы имели одинаковые сигнатуры; на практике это означает, что только переменные, связанные одним и тем же шаблоном связи, должны иметь одинаковые контексты. Например, это нормально:

f :: Eq a => a -> Bool
f x = (x == x) || g True

g :: Ord a => a -> Bool
g y = (y <= y) || f True

16.1.1.6. Заголовки модулей по умолчанию с -main-is

Отчёт Haskell2010 указывает в <https://www.haskell.org/onlinereport/haskell2010/haskellch5.html#x11-990005.1>, что

«Допускается сокращённая форма модуля, состоящая только из тела модуля,

в этом случае заголовок предполагается module Main(main) where.

Опция GHC -main-is позволяет изменить имя точки входа верхнего уровня с main на любое другое имя переменной. При компиляции основного модуля и использовании -main-is для переименования точки входа по умолчанию, GHC также будет использовать альтернативное имя в списке экспорта по умолчанию.

Рассмотрим следующую программу:

-- file: Main.hs
program :: IO ()
program = return ()

GHC успешно скомпилирует этот модуль с ghc -main-is Main.program Main.hs, потому что список экспорта по умолчанию будет включать program вместо main, как это обычно требуется в отчёте Haskell.

Это изменение применяется только к главному модулю. Другие модули по-прежнему будут экспортировать main из списка экспорта по умолчанию, независимо от флага -main-is. Это позволяет использовать -main-is с существующими модулями, которые экспортируют main через список экспорта по умолчанию, даже когда -main-is указывает на другую точку входа, как в этом примере (скомпилированном с -main-is MainWrapper.program).

-- file MainWrapper.hs
module MainWrapper where
import Main

program :: IO ()
program = putStrLn "Redirecting..." >> main

-- file Main.hs
main :: IO ()
main = putStrLn "I am main."

16.1.1.7. Система модулей и файлы интерфейса

GHC требует использования файлов hs-boot для разрыва рекурсивных циклов между взаимно рекурсивными модулями, как описано в Взаимно рекурсивные модули и файлы hs-boot. Это скорее недостаток, чем ошибка: в отчёте Haskell говорится (Раздел 5.7)

«В зависимости от используемой реализации Haskell, для отдельной компиляции взаимно рекурсивных модулей может потребоваться, чтобы импортируемые модули содержали дополнительную информацию, чтобы они могли быть обработаны до компиляции. Возможно, потребуются явные типы сигнатур для всех экспортированных значений, чтобы справиться с взаимной рекурсией. Точные детали отдельной компиляции не определены в данном отчёте.»

16.1.1.8. Числа, базовые типы и встроенные классы

Num superclasses

Класс Num не имеет Show или Eq суперклассов.

Вы можете написать код, который работает как с Haskell98/Haskell2010, так и с GHC, если:

• При создании экземпляра Num типа также создайте экземпляры Show и Eq и
• При указании функции, экземпляра или класса с ограничением Num t также укажите ограничения Show t и Eq t.

Bits superclass

Класс Bits не имеет суперкласса Num. Следовательно, он не имеет методов по умолчанию для методов bit, testBit и popCount.

Вы можете написать код, работающий как с Haskell 2010, так и с GHC, если:

• При создании экземпляра Bits типа также создайте экземпляр Num, и
• При указании функции, экземпляра или класса с ограничением Bits t также укажите ограничение Num t, и
• Всегда определенйте методы bit, testBit и popCount в экземплярах Bits.

Read class methods

Класс Read имеет два дополнительных метода, readPrec и readListPrec, которые отсутствуют в Haskell 2010, так как они опираются на тип ReadPrec , который требует расширения RankNTypes. GHC также выводит экземпляры Read , реализуя readPrec вместо readsPrec, и опирается на реализацию по умолчанию readsPrec, определённую через readPrec. GHC добавляет эти два дополнительных метода просто потому, что ReadPrec более эффективен, чем ReadS (тип, на котором основан readsPrec).

Monad superclass

Класс Monad имеет суперкласс Applicative. Невозможно создать экземпляры Monad, которые работают как в GHC, так и в реализации Haskell 2010, которая не определяет Applicative.

Дополнительные экземпляры

Определены следующие дополнительные экземпляры:

instance Functor ((->) r)
instance Monad ((->) r)
instance Functor ((,) a)
instance Functor (Either a)
instance Monad (Either e)

Не проверяемые многократно определенные элементы массива

Этот фрагмент кода должен вызывать ошибку, но этого не происходит:

main = print (array (1,1) [(1,2), (1,3)])

Реализация array в GHC берёт значение ячейки массива из последней пары (индекс, значение) в списке и не проверяет дубликаты. Причина — эффективность.

16.1.1.9. Поддержка в Prelude

splitAt semantics

Data.List.splitAt более строгий, чем указано в отчёте. В частности, в отчёте указано, что

splitAt n xs = (take n xs, drop n xs)

что подразумевает, что

splitAt undefined undefined = (undefined, undefined)

но реализация GHC строго относится к первому аргументу, поэтому

splitAt undefined [] = undefined

Showing records

Определение Show в Haskell 2010 указывает, что результирующая строка должна содержать только скобки, необходимые для однозначной обработки результата. По историческим причинам экземпляры Show , полученные в GHC, включают скобки вокруг записей, несмотря на то, что синтаксис записи сильнее связывает, чем функция приложения; например,

data Hello = Hello { aField :: Int } deriving (Show)

-- GHC produces...
show (Just (Hello {aField=42})) == "Just (Hello {aField=42})"

-- whereas Haskell 2010 calls for...
show (Just (Hello {aField=42})) == "Just Hello {aField=42}"

Reading integers

Реализация класса Read для целочисленных типов в GHC поддерживает шестнадцатеричные, восьмеричные и двоичные литералы (в отчёте по Haskell 98 это не так). Например,

read "0xf00" :: Int

работает в GHC.

Это делается для поддержания согласованности с синтаксисом языка. Haskell98 поддерживает шестнадцатеричные и восьмеричные форматы, а GHC2021 — и двоичные.

isAlpha

Определение isAlpha в Haskell 98:

isAlpha c = isUpper c || isLower c

Реализация GHC отличается от определения Haskell 98 в том, что буквенные символы Юникода, которые не являются заглавными или строчными, всё ещё будут считаться буквенными символами функцией isAlpha.

hGetContents

Лень-ввод (Lazy I/O) генерирует исключение при возникновении ошибки, в отличие от спецификации Haskell 98, которая требует игнорирования ошибок (см. раздел 21.2.2 отчёта Haskell 98). Генерируемое исключение — это обычное исключение ввода/вывода, которое было бы сгенерировано при выполнении неудачной операции ввода/вывода в монаде ввода/вывода, и его можно перехватить с помощью System.IO.Error.catch или Control.Exception.catch.

16.1.1.10. Интерфейс внешних функций

hs_init(), hs_exit()

Спецификация FFI требует, чтобы реализация поддерживала повторную инициализацию после завершения работы с hs_exit(), но в настоящее время GHC это не поддерживает. См. #13693.