Text.ParserCombinators.ReadP

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

Тип ReadP

data ReadP a Источник

Основные операции

get :: ReadP Символ Исходный код

Потребляет и возвращает следующий символ. Возвращает ошибку, если входных данных не осталось.

look :: ReadP Строка Исходный код

Предварительный просмотр: возвращает оставшуюся часть входных данных, не потребляя их.

(+++) :: ReadP a -> ReadP a -> ReadP a infixr 5 Source

Симметричный выбор.

(<++) :: ReadP a -> ReadP a -> ReadP a infixr 5 Source

Локальный, исключительный, левосторонний выбор: если левый анализатор локально порождает какой-либо результат, то правый анализатор не используется.

gather :: ReadP a -> ReadP (String, a) Source

Преобразует анализатор в анализатор, который делает то же самое, но дополнительно возвращает точные прочитанные символы. ВАЖНОЕ ПРИМЕЧАНИЕ: gather вызывает ошибку во время выполнения, если его первый аргумент построен с использованием любых вхождений readS_to_P.

Другие операции

pfail :: ReadP a Source

Всегда завершается ошибкой.

eof :: ReadP () Source

Успешно завершается, если мы находимся в конце входных данных

satisfy :: (Char -> Bool) -> ReadP Char Source

Потребляет и возвращает следующий символ, если он удовлетворяет заданному предикату.

char :: Char -> ReadP Char Source

Анализирует и возвращает указанный символ.

string :: String -> ReadP String Source

Анализирует и возвращает указанную строку.

munch :: (Char -> Bool) -> ReadP String Source

Анализирует первый ноль или более символов, удовлетворяющих предикату. Всегда успешно, точно один раз, прочитав все символы. Таким образом, НЕ то же самое, что (many (satisfy p)).

munch1 :: (Char -> Bool) -> ReadP String Source

Анализирует первый один или более символов, удовлетворяющих предикату. Возвращает ошибку, если их нет, в противном случае успешно завершается ровно один раз, прочитав все символы. Таким образом, НЕ то же самое, что (many1 (satisfy p)).

skipSpaces :: ReadP () Source

Пропускает все пробелы.

choice :: [ReadP a] -> ReadP a Source

Объединяет все анализаторы в указанном списке.

count :: Int -> ReadP a -> ReadP [a] Source

count n p анализирует n вхождения p последовательно. Возвращается список результатов.

between :: ReadP open -> ReadP close -> ReadP a -> ReadP a Source

between open close p анализирует open, за которым следует p и, наконец, close. Возвращается только значение p.

option :: a -> ReadP a -> ReadP a Source

option x p будет либо анализировать p, либо возвращать x без потребления каких-либо входных данных.

optional :: ReadP a -> ReadP () Source

optional p необязательно анализирует p и всегда возвращает ().

many :: ReadP a -> ReadP [a] Source

Анализирует ноль или более вхождений данного анализатора.

many1 :: ReadP a -> ReadP [a] Source

Анализирует одно или более вхождений данного анализатора.

skipMany :: ReadP a -> ReadP () Source

Как many, но отбрасывает результат.

skipMany1 :: ReadP a -> ReadP () Source

Как many1, но отбрасывает результат.

sepBy :: ReadP a -> ReadP sep -> ReadP [a] Source

sepBy p sep анализирует ноль или более вхождений p, разделенных sep. Возвращает список значений, возвращаемых p.

sepBy1 :: ReadP a -> ReadP sep -> ReadP [a] Source

sepBy1 p sep анализирует одно или более вхождений p, разделённых sep. Возвращает список значений, возвращённых p.

endBy :: ReadP a -> ReadP sep -> ReadP [a] Source

endBy p sep анализирует ноль или более вхождений p, разделённых и завершаемых sep.

endBy1 :: ReadP a -> ReadP sep -> ReadP [a] Source

endBy p sep анализирует одно или более вхождений p, разделённых и завершаемых sep.

chainr :: ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a Source

chainr p op x анализирует ноль или более вхождений p, разделённых op. Возвращает значение, полученное путём правой ассоциативной применения всех функций, возвращённых op. Если вхождений p нет, возвращается x.

chainl :: ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a Source

chainl p op x анализирует ноль или более вхождений p, разделённых op. Возвращает значение, полученное путём левой ассоциативной применения всех функций, возвращённых op. Если вхождений p нет, возвращается x.

chainl1 :: ReadP a -> ReadP (a -> a -> a) -> ReadP a Source

Аналогично chainl, но анализирует одно или более вхождений p.

chainr1 :: ReadP a -> ReadP (a -> a -> a) -> ReadP a Source

Аналогично chainr, но анализирует одно или более вхождений p.

manyTill :: ReadP a -> ReadP end -> ReadP [a] Source

manyTill p end анализирует ноль или более вхождений p, пока end не выполнится успешно. Возвращает список значений, возвращённых p.

Запуск парсера

type ReadS a = String -> [(a, String)] Source

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

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

readP_to_S :: ReadP a -> ReadS a Source

Преобразует парсер в функцию стиля Haskell ReadS. Это основной способ "запустить" парсер ReadP: расширенный тип readP_to_S :: ReadP a -> String -> [(a,String)] .

readS_to_P :: ReadS a -> ReadP a Source

Преобразует функцию стиля Haskell ReadS в парсер. Предупреждение: это вводит локальную обратную отработку в результирующем парсере, а следовательно, и возможную неэффективность.

Свойства

Следующие являются спецификациями QuickCheck того, что делают комбинированные функции. Их можно рассматривать как формальные спецификации поведения комбинированных функций.

Для некоторых значений нас интересует только содержимое списков, а не их порядок,

(=~) :: Ord a => [a] -> [a] -> Bool
xs =~ ys = sort xs == sort ys

Ниже приведены свойства:

>>> readP_to_S get []
[]

\c str -> readP_to_S get (c:str) == [(c, str)]

\str -> readP_to_S look str == [(str, str)]

\str -> readP_to_S pfail str == []

\x str -> readP_to_S (return x) s == [(x,s)]

prop_Bind p k s =
   readP_to_S (p >>= k) s =~
     [ ys''
     | (x,s') <- readP_to_S p s
     , ys''   <- readP_to_S (k (x::Int)) s'
     ]

prop_Plus p q s =
  readP_to_S (p +++ q) s =~
    (readP_to_S p s ++ readP_to_S q s)

prop_LeftPlus p q s =
  readP_to_S (p <++ q) s =~
    (readP_to_S p s +<+ readP_to_S q s)
 where
  [] +<+ ys = ys
  xs +<+ _  = xs

prop_Gather s =
  forAll readPWithoutReadS $ \p ->
    readP_to_S (gather p) s =~
      [ ((pre,x::Int),s')
      | (x,s') <- readP_to_S p s
      , let pre = take (length s - length s') s
      ]

\this str -> readP_to_S (string this) (this ++ str) == [(this,str)]

prop_String_Maybe this s =
  readP_to_S (string this) s =~
    [(this, drop (length this) s) | this `isPrefixOf` s]

prop_Munch p s =
  readP_to_S (munch p) s =~
    [(takeWhile p s, dropWhile p s)]

prop_Munch1 p s =
  readP_to_S (munch1 p) s =~
    [(res,s') | let (res,s') = (takeWhile p s, dropWhile p s), not (null res)]

prop_Choice ps s =
  readP_to_S (choice ps) s =~
    readP_to_S (foldr (+++) pfail ps) s

prop_ReadS r s =
  readP_to_S (readS_to_P r) s =~ r s