GHC.Read

Авторские права	(c) Университет Глазго 1994-2002
Лицензия	см. libraries/base/LICENSE
Поддержка	cvs-ghc@haskell.org
Стабильность	внутренняя
Переносимость	непереносимая (расширения GHC)
Безопасный Haskell	Достоверный
Язык	Haskell2010

класс Read a где Исходный код

Разбор String, генерирующий значения.

Производные экземпляры Read делают следующие предположения, которым подчиняются производные экземпляры Show:

• Если конструктор определен как инфиксный оператор, то производный экземпляр Read будет анализировать только инфиксные применения конструктора (а не префиксную форму).
• Ассоциативность не используется для сокращения скобок, хотя приоритет может быть использован.
• Если конструктор определен с помощью синтаксиса записи, производный экземпляр Read будет анализировать только форму синтаксиса записи, и, более того, поля должны быть указаны в том же порядке, что и в исходном объявлении.
• Производный экземпляр Read допускает произвольные пробелы Haskell между токенами входной строки. Допускаются также дополнительные скобки.

Например, при объявлениях

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

производный экземпляр Read в Haskell 2010 эквивалентен

instance (Read a) => Read (Tree a) where

        readsPrec d r =  readParen (d > app_prec)
                         (\r -> [(Leaf m,t) |
                                 ("Leaf",s) <- lex r,
                                 (m,t) <- readsPrec (app_prec+1) s]) r

                      ++ readParen (d > up_prec)
                         (\r -> [(u:^:v,w) |
                                 (u,s) <- readsPrec (up_prec+1) r,
                                 (":^:",t) <- lex s,
                                 (v,w) <- readsPrec (up_prec+1) t]) r

          where app_prec = 10
                up_prec = 5

Обратите внимание, что правоассоциативность :^: не используется.

Производный экземпляр в GHC эквивалентен

instance (Read a) => Read (Tree a) where

        readPrec = parens $ (prec app_prec $ do
                                 Ident "Leaf" <- lexP
                                 m <- step readPrec
                                 return (Leaf m))

                     +++ (prec up_prec $ do
                                 u <- step readPrec
                                 Symbol ":^:" <- lexP
                                 v <- step readPrec
                                 return (u :^: v))

          where app_prec = 10
                up_prec = 5

        readListPrec = readListPrecDefault

Почему существуют и readsPrec, и readPrec, и почему GHC выбирает реализацию readPrec в производных экземплярах Read вместо readsPrec? Причина в том, что readsPrec основана на типе ReadS, и хотя ReadS упоминается в отчёте Haskell 2010, это не очень эффективный тип данных для парсера.

readPrec, с другой стороны, основан на гораздо более эффективном типе данных ReadPrec (также известном как "парсеры нового стиля"), но его определение основано на использовании расширения языка RankNTypes. Поэтому readPrec (и его родственник readListPrec) помечены как специфичные для GHC. Тем не менее, рекомендуется использовать readPrec вместо readsPrec всякий раз, когда это возможно, для повышения эффективности.

Как уже упоминалось, производные экземпляры Read в GHC будут реализовывать readPrec вместо readsPrec. Стандартные реализации readsPrec (и его родственника, readList) просто используют readPrec под капотом. Если вы пишете экземпляр Read вручную, рекомендуется сделать это следующим образом:

instance Read T where
  readPrec     = ...
  readListPrec = readListPrecDefault

type ReadS a = String -> [(a, String)] Исходный код

Парсер для типа a, представленный как функция, которая принимает String и возвращает список возможных парсеров в виде (a,String) пар.

Обратите внимание, что этот вид парсера с возвратом очень неэффективен; чтение большой структуры может быть довольно медленным (см. ReadP).

lex :: ReadS String Исходный код

Функция lex считывает одно лексему из входных данных, игнорирует начальные пробелы и возвращает символы, составляющие лексему. Если строка ввода содержит только пробелы, lex возвращает единственный успешный `lexeme', состоящий из пустой строки. (Таким образом lex "" = [("","")].) Если в начале входной строки нет законной лексемы, lex терпит неудачу (т.е. возвращает []).

Этот лексический анализатор не полностью соответствует синтаксису Haskell в следующих отношениях:

• Квалифицированные имена обрабатываются неправильно
• Восьмеричные и шестнадцатеричные числа не распознаются как один токен
• Комментарии не обрабатываются должным образом

lexLitChar :: ReadS String Исходный код

Прочитайте строковое представление символа, используя соглашения об эскейпах языка Haskell. Например:

lexLitChar  "\\nHello"  =  [("\\n", "Hello")]

readLitChar :: ReadS Char Исходный код

Прочитайте строковое представление символа, используя соглашения об эскейпах языка Haskell, и преобразуйте его в символ, который он кодирует. Например:

readLitChar "\\nHello"  =  [('\n', "Hello")]

lexDigits :: ReadS String Исходный код

Считывает непустую строку десятичных цифр.

lexP :: ReadPrec Lexeme Исходный код

Разбор одной лексемы

expectP :: Lexeme -> ReadPrec () Исходный код

paren :: ReadPrec a -> ReadPrec a Исходный код

(paren p) разбирает "(P0)", где p разбирает "P0" в контексте приоритета ноль

parens :: ReadPrec a -> ReadPrec a Исходный код

(parens p) парсит "P", "(P0)", "((P0))" и т.д., где p парсит "P" в текущем контексте приоритета, а парсит "P0" в контексте приоритета ноль

list :: ReadPrec a -> ReadPrec [a] Source

(list p) парсит список элементов, полученных с помощью p, используя обычный синтаксис в квадратных скобках.

choose :: [(String, ReadPrec a)] -> ReadPrec a Source

Парсит указанный лексему и продолжает по указанию. Особенно полезно для нульарных конструкторов; например, choose [("A", return A), ("B", return B)] Мы сопоставляем как Ident, так и Symbol, потому что конструктор может быть оператором, например (:~:)

readListDefault :: Read a => ReadS [a] Source

Возможная замена определения для метода readList (только GHC). Это необходимо только для GHC и даже тогда только для Read экземпляров, где readListPrec не определено как readListPrecDefault.

readListPrecDefault :: Read a => ReadPrec [a] Source

Возможная замена определения для метода readListPrec, определенного с использованием readPrec (только GHC).

readNumber :: Num a => (Lexeme -> ReadPrec a) -> ReadPrec a Source

readField :: String -> ReadPrec a -> ReadPrec a Source

Read парсер для поля записи в формате fieldName=value. fieldName должно быть идентификатором в алфавитно-цифровом формате; для имён полей в стиле символов (операторов), например, (#), используйте readSymField). Второй аргумент — парсер для значения поля.

readFieldHash :: String -> ReadPrec a -> ReadPrec a Source

Read парсер для поля записи в формате fieldName#=value. То есть алфавитно-цифрового идентификатора fieldName за которым следует символ #. Второй аргумент — парсер для значения поля.

Обратите внимание, что readField не подходит для этой цели из-за #5041.

readSymField :: String -> ReadPrec a -> ReadPrec a Source

Read парсер для поля записи в стиле символа в формате (###)=value (где ### — имя поля). Имя поля должно быть символом (оператором), например, (#). Для обычных (алфавитно-цифровых) имён полей используйте readField. Второй аргумент — парсер для значения поля.

readParen :: Bool -> ReadS a -> ReadS a Source

readParen True p парсит то, что парсит p, но заключённое в скобки.

readParen False p парсит то, что парсит p, но необязательно заключённое в скобки.