|Portability||non-portable (uses Text.ParserCombinators.ReadP)|
Converting strings to values.
The Text.Read library is the canonical library to import for
Read-class facilities. For GHC only, it offers an extended and much
Read class, which constitutes a proposed alternative to the
Read. In particular, writing parsers is easier, and
the parsers are much more efficient.
- class Read a where
- type ReadS a = String -> [(a, String)]
- reads :: Read a => ReadS a
- read :: Read a => String -> a
- readParen :: Bool -> ReadS a -> ReadS a
- lex :: ReadS String
- module Text.ParserCombinators.ReadPrec
- data Lexeme
- lexP :: ReadPrec Lexeme
- parens :: ReadPrec a -> ReadPrec a
- readListDefault :: Read a => ReadS [a]
- readListPrecDefault :: Read a => ReadPrec [a]
Strings, producing values.
Derived instances of
Read make the following assumptions, which
derived instances of
- If the constructor is defined to be an infix operator, then the
Readinstance 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 derived
Readwill parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.
- The derived
Readinstance 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 of
Read 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
the operator precedence of the enclosing
context (a number from
|-> ReadS a|
attempts to parse a value from the front of the string, returning a list of (parsed value, remaining string) pairs. If there is no successful parse, the returned list is empty.
Derived instances of
Text.Show.Show satisfy the following:
(x,"")is an element of
Text.Show.showsPrecd x ""))
readsPrec parses the string produced by
Text.Show.showsPrec, and delivers the value that
Text.Show.showsPrec started with.
readList is provided to allow the programmer to
give a specialised way of parsing lists of values.
For example, this is used by the predefined
Read instance of
Char type, where values of type
String should be are
expected to use double quotes, rather than square brackets.
Proposed replacement for
readsPrec using new-style parsers (GHC only).
Haskell 98 functions
read function reads input from a string, which must be
completely consumed by the input process.
lex 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. (Thus
.) If there is no legal lexeme at the
beginning of the input string,
lex "" = [("","")]
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
New parsing functions
String literal, with escapes interpreted
Punctuation or reserved symbol, e.g.
Haskell identifier, e.g.
Haskell symbol, e.g.
Floating point literal
(parens p) parses "P", "(P0)", "((P0))", etc,
p parses "P" in the current precedence context
and parses "P0" in precedence context zero