Text.Read

base-4.9.0.0: Basic libraries

Copyright | (c) The University of Glasgow 2001
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Stability | provisional
Portability | non-portable (uses Text.ParserCombinators.ReadP)
Safe Haskell | Trustworthy
Language | Haskell2010

Text.Read

Contents

- The `Read` class
- Haskell 2010 functions
- New parsing functions

Description

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 improved `Read` class, which constitutes a proposed alternative to the Haskell 2010 `Read`. In particular, writing parsers is easier, and the parsers are much more efficient.

Synopsis

- 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
  - = Char Char
  - | String String
  - | Punc String
  - | Ident String
  - | Symbol String
  - | Number Number
  - | EOF
- lexP :: ReadPrec Lexeme
- parens :: ReadPrec a -> ReadPrec a
- readListDefault :: Read a => ReadS [a]
- readListPrecDefault :: Read a => ReadPrec [a]
- readEither :: Read a => String -> Either String a
- readMaybe :: Read a => String -> Maybe a

# The `Read` class

class Read a where Source

Parsing of `String`s, producing values.

Derived instances of `Read` make the following assumptions, which derived instances of `Show` obey:

- If the constructor is defined to be an infix operator, then the derived `Read` 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 derived `Read` will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.
- The derived `Read` 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 of `Read` in Haskell 2010 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

Minimal complete definition

readsPrec | readPrec

Methods

readsPrec :: Int -> ReadS a Source

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 `Read` and `Show` satisfy the following:

- `(x,"")` is an element of `(`readsPrec` d (`showsPrec` d x ""))`.

That is, `readsPrec` parses the string produced by `showsPrec`, and delivers the value that `showsPrec` started with.

readList :: ReadS [a] Source

The method `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 the `Char` type, where values of type `String` should be are expected to use double quotes, rather than square brackets.

readPrec :: ReadPrec a Source

Proposed replacement for `readsPrec` using new-style parsers (GHC only).

readListPrec :: ReadPrec [a] Source

Proposed replacement for `readList` using new-style parsers (GHC only). The default definition uses `readList`. Instances that define `readPrec` should also define `readListPrec` as `readListPrecDefault`.

Instances

Read Bool |
Methods readsPrec :: Int -> ReadS Bool Source readList :: ReadS [Bool] Source readPrec :: ReadPrec Bool Source readListPrec :: ReadPrec [Bool] Source
Read Char |
Methods readsPrec :: Int -> ReadS Char Source readList :: ReadS [Char] Source readPrec :: ReadPrec Char Source readListPrec :: ReadPrec [Char] Source
Read Double |
Methods readsPrec :: Int -> ReadS Double Source readList :: ReadS [Double] Source readPrec :: ReadPrec Double Source readListPrec :: ReadPrec [Double] Source
Read Float |
Methods readsPrec :: Int -> ReadS Float Source readList :: ReadS [Float] Source readPrec :: ReadPrec Float Source readListPrec :: ReadPrec [Float] Source
Read Int |
Methods readsPrec :: Int -> ReadS Int Source readList :: ReadS [Int] Source readPrec :: ReadPrec Int Source readListPrec :: ReadPrec [Int] Source
Read Int8 |
Methods readsPrec :: Int -> ReadS Int8 Source readList :: ReadS [Int8] Source readPrec :: ReadPrec Int8 Source readListPrec :: ReadPrec [Int8] Source
Read Int16 |
Methods readsPrec :: Int -> ReadS Int16 Source readList :: ReadS [Int16] Source readPrec :: ReadPrec Int16 Source readListPrec :: ReadPrec [Int16] Source
Read Int32 |
Methods readsPrec :: Int -> ReadS Int32 Source readList :: ReadS [Int32] Source readPrec :: ReadPrec Int32 Source readListPrec :: ReadPrec [Int32] Source
Read Int64 |
Methods readsPrec :: Int -> ReadS Int64 Source readList :: ReadS [Int64] Source readPrec :: ReadPrec Int64 Source readListPrec :: ReadPrec [Int64] Source
Read Integer |
Methods readsPrec :: Int -> ReadS Integer Source readList :: ReadS [Integer] Source readPrec :: ReadPrec Integer Source readListPrec :: ReadPrec [Integer] Source
Read Ordering |
Methods readsPrec :: Int -> ReadS Ordering Source readList :: ReadS [Ordering] Source readPrec :: ReadPrec Ordering Source readListPrec :: ReadPrec [Ordering] Source
Read Word |
Methods readsPrec :: Int -> ReadS Word Source readList :: ReadS [Word] Source readPrec :: ReadPrec Word Source readListPrec :: ReadPrec [Word] Source
Read Word8 |
Methods readsPrec :: Int -> ReadS Word8 Source readList :: ReadS [Word8] Source readPrec :: ReadPrec Word8 Source readListPrec :: ReadPrec [Word8] Source
Read Word16 |
Methods readsPrec :: Int -> ReadS Word16 Source readList :: ReadS [Word16] Source readPrec :: ReadPrec Word16 Source readListPrec :: ReadPrec [Word16] Source
Read Word32 |
Methods readsPrec :: Int -> ReadS Word32 Source readList :: ReadS [Word32] Source readPrec :: ReadPrec Word32 Source readListPrec :: ReadPrec [Word32] Source
Read Word64 |
Methods readsPrec :: Int -> ReadS Word64 Source readList :: ReadS [Word64] Source readPrec :: ReadPrec Word64 Source readListPrec :: ReadPrec [Word64] Source
Read () |
Methods readsPrec :: Int -> ReadS () Source readList :: ReadS [()] Source readPrec :: ReadPrec () Source readListPrec :: ReadPrec [()] Source
Read GeneralCategory |
Methods readsPrec :: Int -> ReadS GeneralCategory Source readList :: ReadS [GeneralCategory] Source readPrec :: ReadPrec GeneralCategory Source readListPrec :: ReadPrec [GeneralCategory] Source
Read Lexeme |
Methods readsPrec :: Int -> ReadS Lexeme Source readList :: ReadS [Lexeme] Source readPrec :: ReadPrec Lexeme Source readListPrec :: ReadPrec [Lexeme] Source
Read SomeSymbol |
Methods readsPrec :: Int -> ReadS SomeSymbol Source readList :: ReadS [SomeSymbol] Source readPrec :: ReadPrec SomeSymbol Source readListPrec :: ReadPrec [SomeSymbol] Source
Read SomeNat |
Methods readsPrec :: Int -> ReadS SomeNat Source readList :: ReadS [SomeNat] Source readPrec :: ReadPrec SomeNat Source readListPrec :: ReadPrec [SomeNat] Source
Read DecidedStrictness |
Methods readsPrec :: Int -> ReadS DecidedStrictness Source readList :: ReadS [DecidedStrictness] Source readPrec :: ReadPrec DecidedStrictness Source readListPrec :: ReadPrec [DecidedStrictness] Source
Read SourceStrictness |
Methods readsPrec :: Int -> ReadS SourceStrictness Source readList :: ReadS [SourceStrictness] Source readPrec :: ReadPrec SourceStrictness Source readListPrec :: ReadPrec [SourceStrictness] Source
Read SourceUnpackedness |
Methods readsPrec :: Int -> ReadS SourceUnpackedness Source readList :: ReadS [SourceUnpackedness] Source readPrec :: ReadPrec SourceUnpackedness Source readListPrec :: ReadPrec [SourceUnpackedness] Source
Read Associativity |
Methods readsPrec :: Int -> ReadS Associativity Source readList :: ReadS [Associativity] Source readPrec :: ReadPrec Associativity Source readListPrec :: ReadPrec [Associativity] Source
Read Fixity |
Methods readsPrec :: Int -> ReadS Fixity Source readList :: ReadS [Fixity] Source readPrec :: ReadPrec Fixity Source readListPrec :: ReadPrec [Fixity] Source
Read Any |
Methods readsPrec :: Int -> ReadS Any Source readList :: ReadS [Any] Source readPrec :: ReadPrec Any Source readListPrec :: ReadPrec [Any] Source
Read All |
Methods readsPrec :: Int -> ReadS All Source readList :: ReadS [All] Source readPrec :: ReadPrec All Source readListPrec :: ReadPrec [All] Source
Read IOMode |
Methods readsPrec :: Int -> ReadS IOMode Source readList :: ReadS [IOMode] Source readPrec :: ReadPrec IOMode Source readListPrec :: ReadPrec [IOMode] Source
Read CUIntMax |
Methods readsPrec :: Int -> ReadS CUIntMax Source readList :: ReadS [CUIntMax] Source readPrec :: ReadPrec CUIntMax Source readListPrec :: ReadPrec [CUIntMax] Source
Read CIntMax |
Methods readsPrec :: Int -> ReadS CIntMax Source readList :: ReadS [CIntMax] Source readPrec :: ReadPrec CIntMax Source readListPrec :: ReadPrec [CIntMax] Source
Read CUIntPtr |
Methods readsPrec :: Int -> ReadS CUIntPtr Source readList :: ReadS [CUIntPtr] Source readPrec :: ReadPrec CUIntPtr Source readListPrec :: ReadPrec [CUIntPtr] Source
Read CIntPtr |
Methods readsPrec :: Int -> ReadS CIntPtr Source readList :: ReadS [CIntPtr] Source readPrec :: ReadPrec CIntPtr Source readListPrec :: ReadPrec [CIntPtr] Source
Read CSUSeconds |
Methods readsPrec :: Int -> ReadS CSUSeconds Source readList :: ReadS [CSUSeconds] Source readPrec :: ReadPrec CSUSeconds Source readListPrec :: ReadPrec [CSUSeconds] Source
Read CUSeconds |
Methods readsPrec :: Int -> ReadS CUSeconds Source readList :: ReadS [CUSeconds] Source readPrec :: ReadPrec CUSeconds Source readListPrec :: ReadPrec [CUSeconds] Source
Read CTime |
Methods readsPrec :: Int -> ReadS CTime Source readList :: ReadS [CTime] Source readPrec :: ReadPrec CTime Source readListPrec :: ReadPrec [CTime] Source
Read CClock |
Methods readsPrec :: Int -> ReadS CClock Source readList :: ReadS [CClock] Source readPrec :: ReadPrec CClock Source readListPrec :: ReadPrec [CClock] Source
Read CSigAtomic |
Methods readsPrec :: Int -> ReadS CSigAtomic Source readList :: ReadS [CSigAtomic] Source readPrec :: ReadPrec CSigAtomic Source readListPrec :: ReadPrec [CSigAtomic] Source
Read CWchar |
Methods readsPrec :: Int -> ReadS CWchar Source readList :: ReadS [CWchar] Source readPrec :: ReadPrec CWchar Source readListPrec :: ReadPrec [CWchar] Source
Read CSize |
Methods readsPrec :: Int -> ReadS CSize Source readList :: ReadS [CSize] Source readPrec :: ReadPrec CSize Source readListPrec :: ReadPrec [CSize] Source
Read CPtrdiff |
Methods readsPrec :: Int -> ReadS CPtrdiff Source readList :: ReadS [CPtrdiff] Source readPrec :: ReadPrec CPtrdiff Source readListPrec :: ReadPrec [CPtrdiff] Source
Read CDouble |
Methods readsPrec :: Int -> ReadS CDouble Source readList :: ReadS [CDouble] Source readPrec :: ReadPrec CDouble Source readListPrec :: ReadPrec [CDouble] Source
Read CFloat |
Methods readsPrec :: Int -> ReadS CFloat Source readList :: ReadS [CFloat] Source readPrec :: ReadPrec CFloat Source readListPrec :: ReadPrec [CFloat] Source
Read CULLong |
Methods readsPrec :: Int -> ReadS CULLong Source readList :: ReadS [CULLong] Source readPrec :: ReadPrec CULLong Source readListPrec :: ReadPrec [CULLong] Source
Read CLLong |
Methods readsPrec :: Int -> ReadS CLLong Source readList :: ReadS [CLLong] Source readPrec :: ReadPrec CLLong Source readListPrec :: ReadPrec [CLLong] Source
Read CULong |
Methods readsPrec :: Int -> ReadS CULong Source readList :: ReadS [CULong] Source readPrec :: ReadPrec CULong Source readListPrec :: ReadPrec [CULong] Source
Read CLong |
Methods readsPrec :: Int -> ReadS CLong Source readList :: ReadS [CLong] Source readPrec :: ReadPrec CLong Source readListPrec :: ReadPrec [CLong] Source
Read CUInt |
Methods readsPrec :: Int -> ReadS CUInt Source readList :: ReadS [CUInt] Source readPrec :: ReadPrec CUInt Source readListPrec :: ReadPrec [CUInt] Source
Read CInt |
Methods readsPrec :: Int -> ReadS CInt Source readList :: ReadS [CInt] Source readPrec :: ReadPrec CInt Source readListPrec :: ReadPrec [CInt] Source
Read CUShort |
Methods readsPrec :: Int -> ReadS CUShort Source readList :: ReadS [CUShort] Source readPrec :: ReadPrec CUShort Source readListPrec :: ReadPrec [CUShort] Source
Read CShort |
Methods readsPrec :: Int -> ReadS CShort Source readList :: ReadS [CShort] Source readPrec :: ReadPrec CShort Source readListPrec :: ReadPrec [CShort] Source
Read CUChar |
Methods readsPrec :: Int -> ReadS CUChar Source readList :: ReadS [CUChar] Source readPrec :: ReadPrec CUChar Source readListPrec :: ReadPrec [CUChar] Source
Read CSChar |
Methods readsPrec :: Int -> ReadS CSChar Source readList :: ReadS [CSChar] Source readPrec :: ReadPrec CSChar Source readListPrec :: ReadPrec [CSChar] Source
Read CChar |
Methods readsPrec :: Int -> ReadS CChar Source readList :: ReadS [CChar] Source readPrec :: ReadPrec CChar Source readListPrec :: ReadPrec [CChar] Source
Read IntPtr |
Methods readsPrec :: Int -> ReadS IntPtr Source readList :: ReadS [IntPtr] Source readPrec :: ReadPrec IntPtr Source readListPrec :: ReadPrec [IntPtr] Source
Read WordPtr |
Methods readsPrec :: Int -> ReadS WordPtr Source readList :: ReadS [WordPtr] Source readPrec :: ReadPrec WordPtr Source readListPrec :: ReadPrec [WordPtr] Source
Read SeekMode |
Methods readsPrec :: Int -> ReadS SeekMode Source readList :: ReadS [SeekMode] Source readPrec :: ReadPrec SeekMode Source readListPrec :: ReadPrec [SeekMode] Source
Read NewlineMode |
Methods readsPrec :: Int -> ReadS NewlineMode Source readList :: ReadS [NewlineMode] Source readPrec :: ReadPrec NewlineMode Source readListPrec :: ReadPrec [NewlineMode] Source
Read Newline |
Methods readsPrec :: Int -> ReadS Newline Source readList :: ReadS [Newline] Source readPrec :: ReadPrec Newline Source readListPrec :: ReadPrec [Newline] Source
Read BufferMode |
Methods readsPrec :: Int -> ReadS BufferMode Source readList :: ReadS [BufferMode] Source readPrec :: ReadPrec BufferMode Source readListPrec :: ReadPrec [BufferMode] Source
Read ExitCode |
Methods readsPrec :: Int -> ReadS ExitCode Source readList :: ReadS [ExitCode] Source readPrec :: ReadPrec ExitCode Source readListPrec :: ReadPrec [ExitCode] Source
Read Fd |
Methods readsPrec :: Int -> ReadS Fd Source readList :: ReadS [Fd] Source readPrec :: ReadPrec Fd Source readListPrec :: ReadPrec [Fd] Source
Read CRLim |
Methods readsPrec :: Int -> ReadS CRLim Source readList :: ReadS [CRLim] Source readPrec :: ReadPrec CRLim Source readListPrec :: ReadPrec [CRLim] Source
Read CTcflag |
Methods readsPrec :: Int -> ReadS CTcflag Source readList :: ReadS [CTcflag] Source readPrec :: ReadPrec CTcflag Source readListPrec :: ReadPrec [CTcflag] Source
Read CSpeed |
Methods readsPrec :: Int -> ReadS CSpeed Source readList :: ReadS [CSpeed] Source readPrec :: ReadPrec CSpeed Source readListPrec :: ReadPrec [CSpeed] Source
Read CCc |
Methods readsPrec :: Int -> ReadS CCc Source readList :: ReadS [CCc] Source readPrec :: ReadPrec CCc Source readListPrec :: ReadPrec [CCc] Source
Read CUid |
Methods readsPrec :: Int -> ReadS CUid Source readList :: ReadS [CUid] Source readPrec :: ReadPrec CUid Source readListPrec :: ReadPrec [CUid] Source
Read CNlink |
Methods readsPrec :: Int -> ReadS CNlink Source readList :: ReadS [CNlink] Source readPrec :: ReadPrec CNlink Source readListPrec :: ReadPrec [CNlink] Source
Read CGid |
Methods readsPrec :: Int -> ReadS CGid Source readList :: ReadS [CGid] Source readPrec :: ReadPrec CGid Source readListPrec :: ReadPrec [CGid] Source
Read CSsize |
Methods readsPrec :: Int -> ReadS CSsize Source readList :: ReadS [CSsize] Source readPrec :: ReadPrec CSsize Source readListPrec :: ReadPrec [CSsize] Source
Read CPid |
Methods readsPrec :: Int -> ReadS CPid Source readList :: ReadS [CPid] Source readPrec :: ReadPrec CPid Source readListPrec :: ReadPrec [CPid] Source
Read COff |
Methods readsPrec :: Int -> ReadS COff Source readList :: ReadS [COff] Source readPrec :: ReadPrec COff Source readListPrec :: ReadPrec [COff] Source
Read CMode |
Methods readsPrec :: Int -> ReadS CMode Source readList :: ReadS [CMode] Source readPrec :: ReadPrec CMode Source readListPrec :: ReadPrec [CMode] Source
Read CIno |
Methods readsPrec :: Int -> ReadS CIno Source readList :: ReadS [CIno] Source readPrec :: ReadPrec CIno Source readListPrec :: ReadPrec [CIno] Source
Read CDev |
Methods readsPrec :: Int -> ReadS CDev Source readList :: ReadS [CDev] Source readPrec :: ReadPrec CDev Source readListPrec :: ReadPrec [CDev] Source
Read GCStats |
Methods readsPrec :: Int -> ReadS GCStats Source readList :: ReadS [GCStats] Source readPrec :: ReadPrec GCStats Source readListPrec :: ReadPrec [GCStats] Source
Read Version |
Methods readsPrec :: Int -> ReadS Version Source readList :: ReadS [Version] Source readPrec :: ReadPrec Version Source readListPrec :: ReadPrec [Version] Source
Read Natural |
Methods readsPrec :: Int -> ReadS Natural Source readList :: ReadS [Natural] Source readPrec :: ReadPrec Natural Source readListPrec :: ReadPrec [Natural] Source
Read Void | Reading a `Void` value is always a parse error, considering `Void` as a data type with no constructors.
Methods readsPrec :: Int -> ReadS Void Source readList :: ReadS [Void] Source readPrec :: ReadPrec Void Source readListPrec :: ReadPrec [Void] Source
Read a => Read [a] |
Methods readsPrec :: Int -> ReadS [a] Source readList :: ReadS [[a]] Source readPrec :: ReadPrec [a] Source readListPrec :: ReadPrec [[a]] Source
Read a => Read (Maybe a) |
Methods readsPrec :: Int -> ReadS (Maybe a) Source readList :: ReadS [Maybe a] Source readPrec :: ReadPrec (Maybe a) Source readListPrec :: ReadPrec [Maybe a] Source
(Integral a, Read a) => Read (Ratio a) |
Methods readsPrec :: Int -> ReadS (Ratio a) Source readList :: ReadS [Ratio a] Source readPrec :: ReadPrec (Ratio a) Source readListPrec :: ReadPrec [Ratio a] Source
Read (U1 p) |
Methods readsPrec :: Int -> ReadS (U1 p) Source readList :: ReadS [U1 p] Source readPrec :: ReadPrec (U1 p) Source readListPrec :: ReadPrec [U1 p] Source
Read p => Read (Par1 p) |
Methods readsPrec :: Int -> ReadS (Par1 p) Source readList :: ReadS [Par1 p] Source readPrec :: ReadPrec (Par1 p) Source readListPrec :: ReadPrec [Par1 p] Source
Read a => Read (Down a) |
Methods readsPrec :: Int -> ReadS (Down a) Source readList :: ReadS [Down a] Source readPrec :: ReadPrec (Down a) Source readListPrec :: ReadPrec [Down a] Source
Read a => Read (Last a) |
Methods readsPrec :: Int -> ReadS (Last a) Source readList :: ReadS [Last a] Source readPrec :: ReadPrec (Last a) Source readListPrec :: ReadPrec [Last a] Source
Read a => Read (First a) |
Methods readsPrec :: Int -> ReadS (First a) Source readList :: ReadS [First a] Source readPrec :: ReadPrec (First a) Source readListPrec :: ReadPrec [First a] Source
Read a => Read (Product a) |
Methods readsPrec :: Int -> ReadS (Product a) Source readList :: ReadS [Product a] Source readPrec :: ReadPrec (Product a) Source readListPrec :: ReadPrec [Product a] Source
Read a => Read (Sum a) |
Methods readsPrec :: Int -> ReadS (Sum a) Source readList :: ReadS [Sum a] Source readPrec :: ReadPrec (Sum a) Source readListPrec :: ReadPrec [Sum a] Source
Read a => Read (Dual a) |
Methods readsPrec :: Int -> ReadS (Dual a) Source readList :: ReadS [Dual a] Source readPrec :: ReadPrec (Dual a) Source readListPrec :: ReadPrec [Dual a] Source
Read a => Read (ZipList a) |
Methods readsPrec :: Int -> ReadS (ZipList a) Source readList :: ReadS [ZipList a] Source readPrec :: ReadPrec (ZipList a) Source readListPrec :: ReadPrec [ZipList a] Source
Read a => Read (Complex a) |
Methods readsPrec :: Int -> ReadS (Complex a) Source readList :: ReadS [Complex a] Source readPrec :: ReadPrec (Complex a) Source readListPrec :: ReadPrec [Complex a] Source
HasResolution a => Read (Fixed a) |
Methods readsPrec :: Int -> ReadS (Fixed a) Source readList :: ReadS [Fixed a] Source readPrec :: ReadPrec (Fixed a) Source readListPrec :: ReadPrec [Fixed a] Source
Read a => Read (NonEmpty a) |
Methods readsPrec :: Int -> ReadS (NonEmpty a) Source readList :: ReadS [NonEmpty a] Source readPrec :: ReadPrec (NonEmpty a) Source readListPrec :: ReadPrec [NonEmpty a] Source
Read a => Read (Option a) |
Methods readsPrec :: Int -> ReadS (Option a) Source readList :: ReadS [Option a] Source readPrec :: ReadPrec (Option a) Source readListPrec :: ReadPrec [Option a] Source
Read m => Read (WrappedMonoid m) |
Methods readsPrec :: Int -> ReadS (WrappedMonoid m) Source readList :: ReadS [WrappedMonoid m] Source readPrec :: ReadPrec (WrappedMonoid m) Source readListPrec :: ReadPrec [WrappedMonoid m] Source
Read a => Read (Last a) |
Methods readsPrec :: Int -> ReadS (Last a) Source readList :: ReadS [Last a] Source readPrec :: ReadPrec (Last a) Source readListPrec :: ReadPrec [Last a] Source
Read a => Read (First a) |
Methods readsPrec :: Int -> ReadS (First a) Source readList :: ReadS [First a] Source readPrec :: ReadPrec (First a) Source readListPrec :: ReadPrec [First a] Source
Read a => Read (Max a) |
Methods readsPrec :: Int -> ReadS (Max a) Source readList :: ReadS [Max a] Source readPrec :: ReadPrec (Max a) Source readListPrec :: ReadPrec [Max a] Source
Read a => Read (Min a) |
Methods readsPrec :: Int -> ReadS (Min a) Source readList :: ReadS [Min a] Source readPrec :: ReadPrec (Min a) Source readListPrec :: ReadPrec [Min a] Source
Read a => Read (Identity a) | This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed
Methods readsPrec :: Int -> ReadS (Identity a) Source readList :: ReadS [Identity a] Source readPrec :: ReadPrec (Identity a) Source readListPrec :: ReadPrec [Identity a] Source
(Read a, Read b) => Read (Either a b) |
Methods readsPrec :: Int -> ReadS (Either a b) Source readList :: ReadS [Either a b] Source readPrec :: ReadPrec (Either a b) Source readListPrec :: ReadPrec [Either a b] Source
Read (f p) => Read (Rec1 f p) |
Methods readsPrec :: Int -> ReadS (Rec1 f p) Source readList :: ReadS [Rec1 f p] Source readPrec :: ReadPrec (Rec1 f p) Source readListPrec :: ReadPrec [Rec1 f p] Source
(Read a, Read b) => Read (a, b) |
Methods readsPrec :: Int -> ReadS (a, b) Source readList :: ReadS [(a, b)] Source readPrec :: ReadPrec (a, b) Source readListPrec :: ReadPrec [(a, b)] Source
Read (Proxy k s) |
Methods readsPrec :: Int -> ReadS (Proxy k s) Source readList :: ReadS [Proxy k s] Source readPrec :: ReadPrec (Proxy k s) Source readListPrec :: ReadPrec [Proxy k s] Source
(Read a, Read b) => Read (Arg a b) |
Methods readsPrec :: Int -> ReadS (Arg a b) Source readList :: ReadS [Arg a b] Source readPrec :: ReadPrec (Arg a b) Source readListPrec :: ReadPrec [Arg a b] Source
Read c => Read (K1 i c p) |
Methods readsPrec :: Int -> ReadS (K1 i c p) Source readList :: ReadS [K1 i c p] Source readPrec :: ReadPrec (K1 i c p) Source readListPrec :: ReadPrec [K1 i c p] Source
(Read (f p), Read (g p)) => Read ((:+:) f g p) |
Methods readsPrec :: Int -> ReadS ((f :+: g) p) Source readList :: ReadS [(f :+: g) p] Source readPrec :: ReadPrec ((f :+: g) p) Source readListPrec :: ReadPrec [(f :+: g) p] Source
(Read (f p), Read (g p)) => Read ((:*:) f g p) |
Methods readsPrec :: Int -> ReadS ((f :*: g) p) Source readList :: ReadS [(f :*: g) p] Source readPrec :: ReadPrec ((f :*: g) p) Source readListPrec :: ReadPrec [(f :*: g) p] Source
Read (f (g p)) => Read ((:.:) f g p) |
Methods readsPrec :: Int -> ReadS ((f :.: g) p) Source readList :: ReadS [(f :.: g) p] Source readPrec :: ReadPrec ((f :.: g) p) Source readListPrec :: ReadPrec [(f :.: g) p] Source
(Read a, Read b, Read c) => Read (a, b, c) |
Methods readsPrec :: Int -> ReadS (a, b, c) Source readList :: ReadS [(a, b, c)] Source readPrec :: ReadPrec (a, b, c) Source readListPrec :: ReadPrec [(a, b, c)] Source
(~) k a b => Read ((:~:) k a b) |
Methods readsPrec :: Int -> ReadS ((k :~: a) b) Source readList :: ReadS [(k :~: a) b] Source readPrec :: ReadPrec ((k :~: a) b) Source readListPrec :: ReadPrec [(k :~: a) b] Source
Coercible k a b => Read (Coercion k a b) |
Methods readsPrec :: Int -> ReadS (Coercion k a b) Source readList :: ReadS [Coercion k a b] Source readPrec :: ReadPrec (Coercion k a b) Source readListPrec :: ReadPrec [Coercion k a b] Source
Read (f a) => Read (Alt k f a) |
Methods readsPrec :: Int -> ReadS (Alt k f a) Source readList :: ReadS [Alt k f a] Source readPrec :: ReadPrec (Alt k f a) Source readListPrec :: ReadPrec [Alt k f a] Source
Read a => Read (Const k a b) | This instance would be equivalent to the derived instances of the `Const` newtype if the `runConst` field were removed
Methods readsPrec :: Int -> ReadS (Const k a b) Source readList :: ReadS [Const k a b] Source readPrec :: ReadPrec (Const k a b) Source readListPrec :: ReadPrec [Const k a b] Source
Read (f p) => Read (M1 i c f p) |
Methods readsPrec :: Int -> ReadS (M1 i c f p) Source readList :: ReadS [M1 i c f p] Source readPrec :: ReadPrec (M1 i c f p) Source readListPrec :: ReadPrec [M1 i c f p] Source
(Read a, Read b, Read c, Read d) => Read (a, b, c, d) |
Methods readsPrec :: Int -> ReadS (a, b, c, d) Source readList :: ReadS [(a, b, c, d)] Source readPrec :: ReadPrec (a, b, c, d) Source readListPrec :: ReadPrec [(a, b, c, d)] Source
(Read1 f, Read1 g, Read a) => Read (Product (TYPE Lifted) f g a) |
Methods readsPrec :: Int -> ReadS (Product (TYPE Lifted) f g a) Source readList :: ReadS [Product (TYPE Lifted) f g a] Source readPrec :: ReadPrec (Product (TYPE Lifted) f g a) Source readListPrec :: ReadPrec [Product (TYPE Lifted) f g a] Source
(Read1 f, Read1 g, Read a) => Read (Sum (TYPE Lifted) f g a) |
Methods readsPrec :: Int -> ReadS (Sum (TYPE Lifted) f g a) Source readList :: ReadS [Sum (TYPE Lifted) f g a] Source readPrec :: ReadPrec (Sum (TYPE Lifted) f g a) Source readListPrec :: ReadPrec [Sum (TYPE Lifted) f g a] Source
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e) Source readList :: ReadS [(a, b, c, d, e)] Source readPrec :: ReadPrec (a, b, c, d, e) Source readListPrec :: ReadPrec [(a, b, c, d, e)] Source
(Read1 f, Read1 g, Read a) => Read (Compose (TYPE Lifted) (TYPE Lifted) f g a) |
Methods readsPrec :: Int -> ReadS (Compose (TYPE Lifted) (TYPE Lifted) f g a) Source readList :: ReadS [Compose (TYPE Lifted) (TYPE Lifted) f g a] Source readPrec :: ReadPrec (Compose (TYPE Lifted) (TYPE Lifted) f g a) Source readListPrec :: ReadPrec [Compose (TYPE Lifted) (TYPE Lifted) f g a] Source
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f) Source readList :: ReadS [(a, b, c, d, e, f)] Source readPrec :: ReadPrec (a, b, c, d, e, f) Source readListPrec :: ReadPrec [(a, b, c, d, e, f)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g) Source readList :: ReadS [(a, b, c, d, e, f, g)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h) Source readList :: ReadS [(a, b, c, d, e, f, g, h)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g, h) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i) Source readList :: ReadS [(a, b, c, d, e, f, g, h, i)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j) Source readList :: ReadS [(a, b, c, d, e, f, g, h, i, j)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k) Source readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l) Source readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m) Source readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] Source readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] Source

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

A parser for a type `a`, represented as a function that takes a `String` 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 (cf `ReadP`).

# Haskell 2010 functions

reads :: Read a => ReadS a Source

equivalent to `readsPrec` with a precedence of 0.

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

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

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

``readParen` `True` p` parses what `p` parses, but surrounded with parentheses.

``readParen` `False` p` parses what `p` parses, but optionally surrounded with parentheses.

lex :: ReadS String Source

The `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 ``lex` "" = [("","")]`.) 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

# New parsing functions

module Text.ParserCombinators.ReadPrec

data Lexeme Source

Constructors

Char Char | Character literal
String String | String literal, with escapes interpreted
Punc String | Punctuation or reserved symbol, e.g. `(`, `::`
Ident String | Haskell identifier, e.g. `foo`, `Baz`
Symbol String | Haskell symbol, e.g. `>>`, `:%`
Number Number | Since: 4.6.0.0
EOF |

Instances

Eq Lexeme |
Methods (==) :: Lexeme -> Lexeme -> Bool Source (/=) :: Lexeme -> Lexeme -> Bool Source
Read Lexeme |
Methods readsPrec :: Int -> ReadS Lexeme Source readList :: ReadS [Lexeme] Source readPrec :: ReadPrec Lexeme Source readListPrec :: ReadPrec [Lexeme] Source
Show Lexeme |
Methods showsPrec :: Int -> Lexeme -> ShowS Source show :: Lexeme -> String Source showList :: [Lexeme] -> ShowS Source

lexP :: ReadPrec Lexeme Source

Parse a single lexeme

parens :: ReadPrec a -> ReadPrec a Source

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

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

A possible replacement definition for the `readList` method (GHC only). This is only needed for GHC, and even then only for `Read` instances where `readListPrec` isn't defined as `readListPrecDefault`.

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

A possible replacement definition for the `readListPrec` method, defined using `readPrec` (GHC only).

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

Parse a string using the `Read` instance. Succeeds if there is exactly one valid result. A `Left` value indicates a parse error.

Since: 4.6.0.0

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

Parse a string using the `Read` instance. Succeeds if there is exactly one valid result.

Since: 4.6.0.0