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 Строка Исходный код

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

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

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

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

module Text.ParserCombinators.ReadPrec

data Лексема Исходный код

lexP :: ReadPrec Лексема Исходный код

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

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

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

readListDefault :: Read a => ReadS [a] Исходный код

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

readListPrecDefault :: Read a => ReadPrec [a] Исходный код

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

readEither :: Read a => Строка -> Either Строка a Исходный код

Разбор строки с помощью примера 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 => Строка -> Может a Исходный код

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

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

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

С версии: base-4.6.0.0