Safe Haskell	Safe

Eta.Classes.Read

Description

The Read type class defines an interface with a method read that allows converting a String into a value. Think of this as a naive form of deserialization.

Synopsis

Documentation

>>> import Prelude(Int)

read :: Read a => String -> Maybe a #

Tries to deserialize a value using the Read type class. If it fails, returns Nothing

>>> read "1" :: Maybe Int
Just 1
>>> read "pizza" :: Maybe Int
Nothing

unsafeRead :: Read a => String -> a #

Tries to deserialize a value using the Read type class. If it fails, it throws an error

>>> unsafeRead "1" :: Int
1

class Read a where #

Minimal complete definition

readsPrec | readPrec

Methods

readsPrec :: Int -> ReadS a #

Instances

Read Bool
Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] readPrec :: ReadPrec Bool readListPrec :: ReadPrec [Bool]
Read Char
Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] readPrec :: ReadPrec Char readListPrec :: ReadPrec [Char]
Read Double
Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] readPrec :: ReadPrec Double readListPrec :: ReadPrec [Double]
Read Float
Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] readPrec :: ReadPrec Float readListPrec :: ReadPrec [Float]
Read Int
Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] readPrec :: ReadPrec Int readListPrec :: ReadPrec [Int]
Read Int8
Methods readsPrec :: Int -> ReadS Int8 # readList :: ReadS [Int8] readPrec :: ReadPrec Int8 readListPrec :: ReadPrec [Int8]
Read Int16
Methods readsPrec :: Int -> ReadS Int16 # readList :: ReadS [Int16] readPrec :: ReadPrec Int16 readListPrec :: ReadPrec [Int16]
Read Int32
Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] readPrec :: ReadPrec Int32 readListPrec :: ReadPrec [Int32]
Read Int64
Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] readPrec :: ReadPrec Int64 readListPrec :: ReadPrec [Int64]
Read Integer
Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] readPrec :: ReadPrec Integer readListPrec :: ReadPrec [Integer]
Read Ordering
Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] readPrec :: ReadPrec Ordering readListPrec :: ReadPrec [Ordering]
Read Word
Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] readPrec :: ReadPrec Word readListPrec :: ReadPrec [Word]
Read ()
Methods readsPrec :: Int -> ReadS () # readList :: ReadS [()] readPrec :: ReadPrec () readListPrec :: ReadPrec [()]
Read GeneralCategory
Methods readsPrec :: Int -> ReadS GeneralCategory # readList :: ReadS [GeneralCategory] readPrec :: ReadPrec GeneralCategory readListPrec :: ReadPrec [GeneralCategory]
Read Lexeme
Methods readsPrec :: Int -> ReadS Lexeme # readList :: ReadS [Lexeme] readPrec :: ReadPrec Lexeme readListPrec :: ReadPrec [Lexeme]
Read Any
Methods readsPrec :: Int -> ReadS Any # readList :: ReadS [Any] readPrec :: ReadPrec Any readListPrec :: ReadPrec [Any]
Read All
Methods readsPrec :: Int -> ReadS All # readList :: ReadS [All] readPrec :: ReadPrec All readListPrec :: ReadPrec [All]
Read SourceUnpackedness
Methods readsPrec :: Int -> ReadS SourceUnpackedness # readList :: ReadS [SourceUnpackedness] readPrec :: ReadPrec SourceUnpackedness readListPrec :: ReadPrec [SourceUnpackedness]
Read SourceStrictness
Methods readsPrec :: Int -> ReadS SourceStrictness # readList :: ReadS [SourceStrictness] readPrec :: ReadPrec SourceStrictness readListPrec :: ReadPrec [SourceStrictness]
Read Fixity
Methods readsPrec :: Int -> ReadS Fixity # readList :: ReadS [Fixity] readPrec :: ReadPrec Fixity readListPrec :: ReadPrec [Fixity]
Read DecidedStrictness
Methods readsPrec :: Int -> ReadS DecidedStrictness # readList :: ReadS [DecidedStrictness] readPrec :: ReadPrec DecidedStrictness readListPrec :: ReadPrec [DecidedStrictness]
Read Associativity
Methods readsPrec :: Int -> ReadS Associativity # readList :: ReadS [Associativity] readPrec :: ReadPrec Associativity readListPrec :: ReadPrec [Associativity]
Read a => Read [a]
Methods readsPrec :: Int -> ReadS [a] # readList :: ReadS [[a]] readPrec :: ReadPrec [a] readListPrec :: ReadPrec [[a]]
Read a => Read (Maybe a)
Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] readPrec :: ReadPrec (Maybe a) readListPrec :: ReadPrec [Maybe a]
(Integral a, Read a) => Read (Ratio a)
Methods readsPrec :: Int -> ReadS (Ratio a) # readList :: ReadS [Ratio a] readPrec :: ReadPrec (Ratio a) readListPrec :: ReadPrec [Ratio a]
Read (V1 p)
Methods readsPrec :: Int -> ReadS (V1 p) # readList :: ReadS [V1 p] readPrec :: ReadPrec (V1 p) readListPrec :: ReadPrec [V1 p]
Read (U1 p)
Methods readsPrec :: Int -> ReadS (U1 p) # readList :: ReadS [U1 p] readPrec :: ReadPrec (U1 p) readListPrec :: ReadPrec [U1 p]
Read p => Read (Par1 p)
Methods readsPrec :: Int -> ReadS (Par1 p) # readList :: ReadS [Par1 p] readPrec :: ReadPrec (Par1 p) readListPrec :: ReadPrec [Par1 p]
Read a => Read (Sum a)
Methods readsPrec :: Int -> ReadS (Sum a) # readList :: ReadS [Sum a] readPrec :: ReadPrec (Sum a) readListPrec :: ReadPrec [Sum a]
Read a => Read (Product a)
Methods readsPrec :: Int -> ReadS (Product a) # readList :: ReadS [Product a] readPrec :: ReadPrec (Product a) readListPrec :: ReadPrec [Product a]
Read a => Read (Last a)
Methods readsPrec :: Int -> ReadS (Last a) # readList :: ReadS [Last a] readPrec :: ReadPrec (Last a) readListPrec :: ReadPrec [Last a]
Read a => Read (First a)
Methods readsPrec :: Int -> ReadS (First a) # readList :: ReadS [First a] readPrec :: ReadPrec (First a) readListPrec :: ReadPrec [First a]
Read a => Read (Dual a)
Methods readsPrec :: Int -> ReadS (Dual a) # readList :: ReadS [Dual a] readPrec :: ReadPrec (Dual a) readListPrec :: ReadPrec [Dual a]
Read a => Read (ZipList a)
Methods readsPrec :: Int -> ReadS (ZipList a) # readList :: ReadS [ZipList a] readPrec :: ReadPrec (ZipList a) readListPrec :: ReadPrec [ZipList a]
(Read b, Read a) => Read (Either a b)
Methods readsPrec :: Int -> ReadS (Either a b) # readList :: ReadS [Either a b] readPrec :: ReadPrec (Either a b) readListPrec :: ReadPrec [Either a b]
Read (f p) => Read (Rec1 f p)
Methods readsPrec :: Int -> ReadS (Rec1 f p) # readList :: ReadS [Rec1 f p] readPrec :: ReadPrec (Rec1 f p) readListPrec :: ReadPrec [Rec1 f p]
(Read a, Read b) => Read (a, b)
Methods readsPrec :: Int -> ReadS (a, b) # readList :: ReadS [(a, b)] readPrec :: ReadPrec (a, b) readListPrec :: ReadPrec [(a, b)]
(Ix a, Read a, Read b) => Read (Array a b)
Methods readsPrec :: Int -> ReadS (Array a b) # readList :: ReadS [Array a b] readPrec :: ReadPrec (Array a b) readListPrec :: ReadPrec [Array a b]
Read (Proxy k s)
Methods readsPrec :: Int -> ReadS (Proxy k s) # readList :: ReadS [Proxy k s] readPrec :: ReadPrec (Proxy k s) readListPrec :: ReadPrec [Proxy k s]
Read c => Read (K1 i c p)
Methods readsPrec :: Int -> ReadS (K1 i c p) # readList :: ReadS [K1 i c p] readPrec :: ReadPrec (K1 i c p) readListPrec :: ReadPrec [K1 i c p]
(Read (g p), Read (f p)) => Read ((:+:) f g p)
Methods readsPrec :: Int -> ReadS ((f :+: g) p) # readList :: ReadS [(f :+: g) p] readPrec :: ReadPrec ((f :+: g) p) readListPrec :: ReadPrec [(f :+: g) p]
(Read (g p), Read (f p)) => Read ((:*:) f g p)
Methods readsPrec :: Int -> ReadS ((f :: g) p) # readList :: ReadS [(f :: g) p] readPrec :: ReadPrec ((f :: g) p) readListPrec :: ReadPrec [(f :: g) p]
Read (f (g p)) => Read ((:.:) f g p)
Methods readsPrec :: Int -> ReadS ((f :.: g) p) # readList :: ReadS [(f :.: g) p] readPrec :: ReadPrec ((f :.: g) p) readListPrec :: ReadPrec [(f :.: g) p]
(Read a, Read b, Read c) => Read (a, b, c)
Methods readsPrec :: Int -> ReadS (a, b, c) # readList :: ReadS [(a, b, c)] readPrec :: ReadPrec (a, b, c) readListPrec :: ReadPrec [(a, b, c)]
Read (f a) => Read (Alt k f a)
Methods readsPrec :: Int -> ReadS (Alt k f a) # readList :: ReadS [Alt k f a] readPrec :: ReadPrec (Alt k f a) readListPrec :: ReadPrec [Alt k f a]
(~) k a b => Read ((:~:) k a b)
Methods readsPrec :: Int -> ReadS ((k :~: a) b) # readList :: ReadS [(k :~: a) b] readPrec :: ReadPrec ((k :~: a) b) readListPrec :: ReadPrec [(k :~: a) b]
Read (f p) => Read (M1 i c f p)
Methods readsPrec :: Int -> ReadS (M1 i c f p) # readList :: ReadS [M1 i c f p] readPrec :: ReadPrec (M1 i c f p) readListPrec :: ReadPrec [M1 i c f p]
(Read a, Read b, Read c, Read d) => Read (a, b, c, d)
Methods readsPrec :: Int -> ReadS (a, b, c, d) # readList :: ReadS [(a, b, c, d)] readPrec :: ReadPrec (a, b, c, d) readListPrec :: ReadPrec [(a, b, c, d)]
(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) # readList :: ReadS [(a, b, c, d, e)] readPrec :: ReadPrec (a, b, c, d, e) readListPrec :: ReadPrec [(a, b, c, d, e)]
(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) # readList :: ReadS [(a, b, c, d, e, f)] readPrec :: ReadPrec (a, b, c, d, e, f) readListPrec :: ReadPrec [(a, b, c, d, e, f)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g)] readPrec :: ReadPrec (a, b, c, d, e, f, g) readListPrec :: ReadPrec [(a, b, c, d, e, f, g)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g, h)] readPrec :: ReadPrec (a, b, c, d, e, f, g, h) readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g, h, i)] readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i) readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j)] readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j) readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k)] readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k) readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)] readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l) readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)] readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m) readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n) readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
(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) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]