Text.Read

base-4.10.1.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

Why do both `readsPrec` and `readPrec` exist, and why does GHC opt to implement `readPrec` in derived `Read` instances instead of `readsPrec`? The reason is that `readsPrec` is based on the `ReadS` type, and although `ReadS` is mentioned in the Haskell 2010 Report, it is not a very efficient parser data structure.

`readPrec`, on the other hand, is based on a much more efficient `ReadPrec` datatype (a.k.a "new-style parsers"), but its definition relies on the use of the `RankNTypes` language extension. Therefore, `readPrec` (and its cousin, `readListPrec`) are marked as GHC-only. Nevertheless, it is recommended to use `readPrec` instead of `readsPrec` whenever possible for the efficiency improvements it brings.

As mentioned above, derived `Read` instances in GHC will implement `readPrec` instead of `readsPrec`. The default implementations of `readsPrec` (and its cousin, `readList`) will simply use `readPrec` under the hood. If you are writing a `Read` instance by hand, it is recommended to write it like so:

    instance Read T where
      readPrec     = ...
      readListPrec = readListPrecDefault

Minimal complete definition

readsPrec | readPrec

Methods

readsPrec Source #

Arguments

:: Int | the operator precedence of the enclosing context (a number from `0` to `11`). Function application has precedence `10`.
-> 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 `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 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Bool Source # readList :: ReadS [Bool] Source # readPrec :: ReadPrec Bool Source # readListPrec :: ReadPrec [Bool] Source #
Read Char # | Since: 2.1
Methods readsPrec :: Int -> ReadS Char Source # readList :: ReadS [Char] Source # readPrec :: ReadPrec Char Source # readListPrec :: ReadPrec [Char] Source #
Read Double # | Since: 2.1
Methods readsPrec :: Int -> ReadS Double Source # readList :: ReadS [Double] Source # readPrec :: ReadPrec Double Source # readListPrec :: ReadPrec [Double] Source #
Read Float # | Since: 2.1
Methods readsPrec :: Int -> ReadS Float Source # readList :: ReadS [Float] Source # readPrec :: ReadPrec Float Source # readListPrec :: ReadPrec [Float] Source #
Read Int # | Since: 2.1
Methods readsPrec :: Int -> ReadS Int Source # readList :: ReadS [Int] Source # readPrec :: ReadPrec Int Source # readListPrec :: ReadPrec [Int] Source #
Read Int8 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Int8 Source # readList :: ReadS [Int8] Source # readPrec :: ReadPrec Int8 Source # readListPrec :: ReadPrec [Int8] Source #
Read Int16 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Int16 Source # readList :: ReadS [Int16] Source # readPrec :: ReadPrec Int16 Source # readListPrec :: ReadPrec [Int16] Source #
Read Int32 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Int32 Source # readList :: ReadS [Int32] Source # readPrec :: ReadPrec Int32 Source # readListPrec :: ReadPrec [Int32] Source #
Read Int64 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Int64 Source # readList :: ReadS [Int64] Source # readPrec :: ReadPrec Int64 Source # readListPrec :: ReadPrec [Int64] Source #
Read Integer # | Since: 2.1
Methods readsPrec :: Int -> ReadS Integer Source # readList :: ReadS [Integer] Source # readPrec :: ReadPrec Integer Source # readListPrec :: ReadPrec [Integer] Source #
Read Natural # | Since: 4.8.0.0
Methods readsPrec :: Int -> ReadS Natural Source # readList :: ReadS [Natural] Source # readPrec :: ReadPrec Natural Source # readListPrec :: ReadPrec [Natural] Source #
Read Ordering # | Since: 2.1
Methods readsPrec :: Int -> ReadS Ordering Source # readList :: ReadS [Ordering] Source # readPrec :: ReadPrec Ordering Source # readListPrec :: ReadPrec [Ordering] Source #
Read Word # | Since: 4.5.0.0
Methods readsPrec :: Int -> ReadS Word Source # readList :: ReadS [Word] Source # readPrec :: ReadPrec Word Source # readListPrec :: ReadPrec [Word] Source #
Read Word8 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Word8 Source # readList :: ReadS [Word8] Source # readPrec :: ReadPrec Word8 Source # readListPrec :: ReadPrec [Word8] Source #
Read Word16 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Word16 Source # readList :: ReadS [Word16] Source # readPrec :: ReadPrec Word16 Source # readListPrec :: ReadPrec [Word16] Source #
Read Word32 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Word32 Source # readList :: ReadS [Word32] Source # readPrec :: ReadPrec Word32 Source # readListPrec :: ReadPrec [Word32] Source #
Read Word64 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Word64 Source # readList :: ReadS [Word64] Source # readPrec :: ReadPrec Word64 Source # readListPrec :: ReadPrec [Word64] Source #
Read () # | Since: 2.1
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 # | Since: 2.1
Methods readsPrec :: Int -> ReadS Lexeme Source # readList :: ReadS [Lexeme] Source # readPrec :: ReadPrec Lexeme Source # readListPrec :: ReadPrec [Lexeme] Source #
Read IOMode # |
Methods readsPrec :: Int -> ReadS IOMode Source # readList :: ReadS [IOMode] Source # readPrec :: ReadPrec IOMode Source # readListPrec :: ReadPrec [IOMode] 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 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 CBool # |
Methods readsPrec :: Int -> ReadS CBool Source # readList :: ReadS [CBool] Source # readPrec :: ReadPrec CBool Source # readListPrec :: ReadPrec [CBool] 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 SomeNat # | Since: 4.7.0.0
Methods readsPrec :: Int -> ReadS SomeNat Source # readList :: ReadS [SomeNat] Source # readPrec :: ReadPrec SomeNat Source # readListPrec :: ReadPrec [SomeNat] Source #
Read SomeSymbol # | Since: 4.7.0.0
Methods readsPrec :: Int -> ReadS SomeSymbol Source # readList :: ReadS [SomeSymbol] Source # readPrec :: ReadPrec SomeSymbol Source # readListPrec :: ReadPrec [SomeSymbol] 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 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 CKey # |
Methods readsPrec :: Int -> ReadS CKey Source # readList :: ReadS [CKey] Source # readPrec :: ReadPrec CKey Source # readListPrec :: ReadPrec [CKey] Source #
Read CId # |
Methods readsPrec :: Int -> ReadS CId Source # readList :: ReadS [CId] Source # readPrec :: ReadPrec CId Source # readListPrec :: ReadPrec [CId] Source #
Read CFsFilCnt # |
Methods readsPrec :: Int -> ReadS CFsFilCnt Source # readList :: ReadS [CFsFilCnt] Source # readPrec :: ReadPrec CFsFilCnt Source # readListPrec :: ReadPrec [CFsFilCnt] Source #
Read CFsBlkCnt # |
Methods readsPrec :: Int -> ReadS CFsBlkCnt Source # readList :: ReadS [CFsBlkCnt] Source # readPrec :: ReadPrec CFsBlkCnt Source # readListPrec :: ReadPrec [CFsBlkCnt] Source #
Read CClockId # |
Methods readsPrec :: Int -> ReadS CClockId Source # readList :: ReadS [CClockId] Source # readPrec :: ReadPrec CClockId Source # readListPrec :: ReadPrec [CClockId] Source #
Read CBlkCnt # |
Methods readsPrec :: Int -> ReadS CBlkCnt Source # readList :: ReadS [CBlkCnt] Source # readPrec :: ReadPrec CBlkCnt Source # readListPrec :: ReadPrec [CBlkCnt] Source #
Read CBlkSize # |
Methods readsPrec :: Int -> ReadS CBlkSize Source # readList :: ReadS [CBlkSize] Source # readPrec :: ReadPrec CBlkSize Source # readListPrec :: ReadPrec [CBlkSize] 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 Version # |
Methods readsPrec :: Int -> ReadS Version Source # readList :: ReadS [Version] Source # readPrec :: ReadPrec Version Source # readListPrec :: ReadPrec [Version] Source #
Read GCStats # |
Methods readsPrec :: Int -> ReadS GCStats Source # readList :: ReadS [GCStats] Source # readPrec :: ReadPrec GCStats Source # readListPrec :: ReadPrec [GCStats] Source #
Read GCDetails # |
Methods readsPrec :: Int -> ReadS GCDetails Source # readList :: ReadS [GCDetails] Source # readPrec :: ReadPrec GCDetails Source # readListPrec :: ReadPrec [GCDetails] Source #
Read RTSStats # |
Methods readsPrec :: Int -> ReadS RTSStats Source # readList :: ReadS [RTSStats] Source # readPrec :: ReadPrec RTSStats Source # readListPrec :: ReadPrec [RTSStats] Source #
Read Void # | Reading a `Void` value is always a parse error, considering `Void` as a data type with no constructors. | @since 4.8.0.0
Methods readsPrec :: Int -> ReadS Void Source # readList :: ReadS [Void] Source # readPrec :: ReadPrec Void Source # readListPrec :: ReadPrec [Void] Source #
Read a => Read [a] # | Since: 2.1
Methods readsPrec :: Int -> ReadS [a] Source # readList :: ReadS [[a]] Source # readPrec :: ReadPrec [a] Source # readListPrec :: ReadPrec [[a]] Source #
Read a => Read (Maybe a) # | Since: 2.1
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) # | Since: 2.1
Methods readsPrec :: Int -> ReadS (Ratio a) Source # readList :: ReadS [Ratio a] Source # readPrec :: ReadPrec (Ratio a) Source # readListPrec :: ReadPrec [Ratio a] 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 (Identity a) # | This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: 4.8.0.0
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 (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 (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 #
HasResolution a => Read (Fixed a) # | Since: 4.3.0.0
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 (Complex a) # |
Methods readsPrec :: Int -> ReadS (Complex a) Source # readList :: ReadS [Complex a] Source # readPrec :: ReadPrec (Complex a) Source # readListPrec :: ReadPrec [Complex a] Source #
(Read b, Read a) => 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 (V1 k p) # |
Methods readsPrec :: Int -> ReadS (V1 k p) Source # readList :: ReadS [V1 k p] Source # readPrec :: ReadPrec (V1 k p) Source # readListPrec :: ReadPrec [V1 k p] Source #
Read (U1 k p) # | Since: 4.9.0.0
Methods readsPrec :: Int -> ReadS (U1 k p) Source # readList :: ReadS [U1 k p] Source # readPrec :: ReadPrec (U1 k p) Source # readListPrec :: ReadPrec [U1 k p] Source #
(Read a, Read b) => Read (a, b) # | Since: 2.1
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) # | Since: 4.7.0.0
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 b, Read a) => 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 (f p) => Read (Rec1 k f p) # |
Methods readsPrec :: Int -> ReadS (Rec1 k f p) Source # readList :: ReadS [Rec1 k f p] Source # readPrec :: ReadPrec (Rec1 k f p) Source # readListPrec :: ReadPrec [Rec1 k f p] Source #
(Read a, Read b, Read c) => Read (a, b, c) # | Since: 2.1
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) # | Since: 4.7.0.0
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) # | Since: 4.7.0.0
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 Since: 4.8.0.0
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 c => Read (K1 k i c p) # |
Methods readsPrec :: Int -> ReadS (K1 k i c p) Source # readList :: ReadS [K1 k i c p] Source # readPrec :: ReadPrec (K1 k i c p) Source # readListPrec :: ReadPrec [K1 k i c p] Source #
(Read (g p), Read (f p)) => Read ((:+:) k f g p) # |
Methods readsPrec :: Int -> ReadS ((k :+: f) g p) Source # readList :: ReadS [(k :+: f) g p] Source # readPrec :: ReadPrec ((k :+: f) g p) Source # readListPrec :: ReadPrec [(k :+: f) g p] Source #
(Read (g p), Read (f p)) => Read ((:*:) k f g p) # |
Methods readsPrec :: Int -> ReadS ((k :*: f) g p) Source # readList :: ReadS [(k :*: f) g p] Source # readPrec :: ReadPrec ((k :*: f) g p) Source # readListPrec :: ReadPrec [(k :*: f) g p] Source #
(Read a, Read b, Read c, Read d) => Read (a, b, c, d) # | Since: 2.1
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 #
(~~) k1 k2 a b => Read ((:~~:) k1 k2 a b) # | Since: 4.10.0.0
Methods readsPrec :: Int -> ReadS ((k1 :~~: k2) a b) Source # readList :: ReadS [(k1 :~~: k2) a b] Source # readPrec :: ReadPrec ((k1 :~~: k2) a b) Source # readListPrec :: ReadPrec [(k1 :~~: k2) a b] Source #
(Read1 f, Read1 g, Read a) => Read (Sum * f g a) # | Since: 4.9.0.0
Methods readsPrec :: Int -> ReadS (Sum * f g a) Source # readList :: ReadS [Sum * f g a] Source # readPrec :: ReadPrec (Sum * f g a) Source # readListPrec :: ReadPrec [Sum * f g a] Source #
(Read1 f, Read1 g, Read a) => Read (Product * f g a) # | Since: 4.9.0.0
Methods readsPrec :: Int -> ReadS (Product * f g a) Source # readList :: ReadS [Product * f g a] Source # readPrec :: ReadPrec (Product * f g a) Source # readListPrec :: ReadPrec [Product * f g a] Source #
Read (f p) => Read (M1 k i c f p) # |
Methods readsPrec :: Int -> ReadS (M1 k i c f p) Source # readList :: ReadS [M1 k i c f p] Source # readPrec :: ReadPrec (M1 k i c f p) Source # readListPrec :: ReadPrec [M1 k i c f p] Source #
Read (f (g p)) => Read ((:.:) k2 k1 f g p) # |
Methods readsPrec :: Int -> ReadS ((k2 :.: k1) f g p) Source # readList :: ReadS [(k2 :.: k1) f g p] Source # readPrec :: ReadPrec ((k2 :.: k1) f g p) Source # readListPrec :: ReadPrec [(k2 :.: k1) f g p] Source #
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) # | Since: 2.1
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 * * f g a) # | Since: 4.9.0.0
Methods readsPrec :: Int -> ReadS (Compose * * f g a) Source # readList :: ReadS [Compose * * f g a] Source # readPrec :: ReadPrec (Compose * * f g a) Source # readListPrec :: ReadPrec [Compose * * f g a] Source #
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) # | Since: 2.1
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) # | Since: 2.1
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) # | Since: 2.1
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) # | Since: 2.1
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) # | Since: 2.1
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) # | Since: 2.1
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) # | Since: 2.1
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) # | Since: 2.1
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) # | Since: 2.1
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) # | Since: 2.1
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 # | Since: 2.1
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