Parsing ofStrings, producing values.

Minimal complete definition:readsPrec (or, for GHC only,readPrec)

Derived instances ofRead make the following assumptions, which derived instances ofText.Show.Show obey:

• If the constructor is defined to be an infix operator, then the derivedRead instance will parse only infix applications of the constructor (not the prefix form).
• Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
• If the constructor is defined using record syntax, the derivedRead will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.
• The derivedRead instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.

For example, given the declarations

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

the derived instance ofRead in Haskell 98 is equivalent to

 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

Note that right-associativity of:^: is unused.

The derived instance in GHC is equivalent to

 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

Methods

readsPrecSource

readList ::ReadS [a]Source

readPrec ::ReadPrec aSource

readListPrec ::ReadPrec [a]Source

Instances

A parser for a typea, represented as a function that takes aString and returns a list of possible parses as(a,String) pairs.

Note that this kind of backtracking parser is very inefficient; reading a large structure may be quite slow (cfReadP).

equivalent toreadsPrec with a precedence of 0.

Theread function reads input from a string, which must be completely consumed by the input process.

readParenTrue p parses whatp parses, but surrounded with parentheses.

readParenFalse p parses whatp parses, but optionally surrounded with parentheses.

Thelex function reads a single lexeme from the input, discarding initial white space, and returning the characters that constitute the lexeme. If the input string contains only white space,lex returns a single successful `lexeme' consisting of the empty string. (Thuslex "" = [("","")].) If there is no legal lexeme at the beginning of the input string,lex fails (i.e. returns[]).

This lexer is not completely faithful to the Haskell lexical syntax in the following respects:

• Qualified names are not handled properly
• Octal and hexadecimal numerics are not recognized as a single token
• Comments are not treated properly

Haskell lexemes.

Constructors

Instances

Parse a single lexeme

(parens p) parses "P", "(P0)", "((P0))", etc, wherep parses "P" in the current precedence context and parses "P0" in precedence context zero

A possible replacement definition for thereadList method (GHC only). This is only needed for GHC, and even then only forRead instances wherereadListPrec isn't defined asreadListPrecDefault.

A possible replacement definition for thereadListPrec method, defined usingreadPrec (GHC only).