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.

• Шаблоны as не должны отделяться пробелами с обеих сторон:

  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 из категории Other Letters считаются строчными буквами, поэтому с них могут начинаться идентификаторы переменных. К классу цифр относятся все числа 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

Начиная с:

7.2.1

Статус:

Включено в 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 (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).

Следуя предложению Марка Джонса из его статьи «Типизация Haskell на 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

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

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

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

Параметр -main-is в GHC можно использовать, чтобы изменить имя точки входа верхнего уровня с 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 считает буквенными также символы Unicode, которые не относятся ни к верхнему, ни к нижнему регистру.

hGetContents

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

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

hs_init(), hs_exit()

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