Text.Read

Авторские права	(с) Университет Глазго 2001
Лицензия	BSD (см. файл libraries/base/LICENSE)
Поддержка	libraries@haskell.org
Устойчивость	предварительная
Переносимость	непереносимая (использует Text.ParserCombinators.ReadP)
Безопасный Haskell	Безопасный
Язык	Haskell2010

Класс Read

class Read a where Исходный код

Парсинг 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)] Source

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

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

Функции Haskell 2010

reads :: Read a => ReadS a Source

эквивалентно readsPrec с приоритетом 0.

read :: Read a => String -> a Source

Функция read считывает входные данные из строки, которая должна быть полностью обработана процессом ввода. read завершается с ошибкой error, если разбор не удался, поэтому не рекомендуется использовать её в реальных приложениях. Используйте readMaybe или readEither в качестве безопасных альтернатив.

>>> read "123" :: Int
123

>>> read "hello" :: Int
*** Exception: Prelude.read: no parse

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

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

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

lex :: ReadS String Source

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

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

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

Новые функции разбора

module Text.ParserCombinators.ReadPrec

data Lexeme Source

lexP :: ReadPrec Lexeme Source

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

parens :: ReadPrec a -> ReadPrec a Source

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

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

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

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

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

readEither :: Read a => String -> Either String a Source

Разбор строки с использованием экземпляра Read. Успешно, если существует ровно один допустимый результат. Значение Left указывает на ошибку разбора.

>>> readEither "123" :: Either String Int
Right 123

>>> readEither "hello" :: Either String Int
Left "Prelude.read: no parse"

С версии: base-4.6.0.0

readMaybe :: Read a => String -> Maybe a Source

Разбор строки с использованием экземпляра Read. Успешно, если существует ровно один допустимый результат.

>>> readMaybe "123" :: Maybe Int
Just 123

>>> readMaybe "hello" :: Maybe Int
Nothing

С версии: base-4.6.0.0