base-4.3.1.0: Basic libraries

Portability | portable
Stability | provisional
Maintainer | libraries@haskell.org

Text.Show

Description

Converting values to readable strings: the `Show` class and associated functions.

Synopsis

- type ShowS = String -> String
- class Show a where
  - showsPrec :: Int -> a -> ShowS
  - show :: a -> String
  - showList :: [a] -> ShowS
- shows :: Show a => a -> ShowS
- showChar :: Char -> ShowS
- showString :: String -> ShowS
- showParen :: Bool -> ShowS -> ShowS
- showListWith :: (a -> ShowS) -> [a] -> ShowS

# Documentation

type ShowS = String -> String

The `shows` functions return a function that prepends the output `String` to an existing `String`. This allows constant-time concatenation of results using function composition.

class Show a where

Conversion of values to readable `String`s.

Minimal complete definition: `showsPrec` or `show`.

Derived instances of `Show` have the following properties, which are compatible with derived instances of `Text.Read.Read`:

- The result of `show` is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
- If the constructor is defined to be an infix operator, then `showsPrec` will produce infix applications of the constructor.
- the representation will be enclosed in parentheses if the precedence of the top-level constructor in `x` is less than `d` (associativity is ignored). Thus, if `d` is `0` then the result is never surrounded in parentheses; if `d` is `11` it is always surrounded in parentheses, unless it is an atomic expression.
- If the constructor is defined using record syntax, then `show` will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

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

the derived instance of `Show` is equivalent to

     instance (Show a) => Show (Tree a) where

            showsPrec d (Leaf m) = showParen (d > app_prec) $
                 showString "Leaf " . showsPrec (app_prec+1) m
              where app_prec = 10

            showsPrec d (u :^: v) = showParen (d > up_prec) $
                 showsPrec (up_prec+1) u .
                 showString " :^: "      .
                 showsPrec (up_prec+1) v
              where up_prec = 5

Note that right-associativity of `:^:` is ignored. For example,

- ``show` (Leaf 1 :^: Leaf 2 :^: Leaf 3)` produces the string `"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"`.

Methods

showsPrec

Arguments

:: Int | the operator precedence of the enclosing context (a number from `0` to `11`). Function application has precedence `10`.
-> a | the value to be converted to a `String`
-> ShowS |

Convert a value to a readable `String`.

`showsPrec` should satisfy the law

     showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)

Derived instances of `Text.Read.Read` and `Show` satisfy the following:

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

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

show :: a -> String

A specialised variant of `showsPrec`, using precedence context zero, and returning an ordinary `String`.

showList :: [a] -> ShowS

The method `showList` is provided to allow the programmer to give a specialised way of showing lists of values. For example, this is used by the predefined `Show` instance of the `Char` type, where values of type `String` should be shown in double quotes, rather than between square brackets.

Instances

Show Bool |
Show Char |
Show Double |
Show Float |
Show Int |
Show Int8 |
Show Int16 |
Show Int32 |
Show Int64 |
Show Integer |
Show Ordering |
Show Word |
Show Word8 |
Show Word16 |
Show Word32 |
Show Word64 |
Show () |
Show TyCon |
Show TypeRep |
Show ArithException |
Show ErrorCall |
Show SomeException |
Show IOException |
Show MaskingState |
Show Lexeme |
Show IOMode |
Show SeekMode |
Show CUIntMax |
Show CIntMax |
Show CUIntPtr |
Show CIntPtr |
Show CTime |
Show CClock |
Show CSigAtomic |
Show CWchar |
Show CSize |
Show CPtrdiff |
Show CDouble |
Show CFloat |
Show CULLong |
Show CLLong |
Show CULong |
Show CLong |
Show CUInt |
Show CInt |
Show CUShort |
Show CShort |
Show CUChar |
Show CSChar |
Show CChar |
Show Any |
Show All |
Show GeneralCategory |
Show HashData |
Show Dynamic |
Show IntPtr |
Show WordPtr |
Show TextEncoding |
Show NewlineMode |
Show Newline |
Show BufferMode |
Show HandleType |
Show Handle |
Show IOErrorType |
Show ExitCode |
Show ArrayException |
Show AsyncException |
Show AssertionFailed |
Show Deadlock |
Show BlockedIndefinitelyOnSTM |
Show BlockedIndefinitelyOnMVar |
Show BlockedIndefinitely |
Show BlockedOnDeadMVar |
Show ThreadStatus |
Show BlockReason |
Show ThreadId |
Show NestedAtomically |
Show NonTermination |
Show NoMethodError |
Show RecUpdError |
Show RecConError |
Show RecSelError |
Show PatternMatchFail |
Show Fd |
Show CRLim |
Show CTcflag |
Show CSpeed |
Show CCc |
Show CUid |
Show CNlink |
Show CGid |
Show CSsize |
Show CPid |
Show COff |
Show CMode |
Show CIno |
Show CDev |
Show Control |
Show ControlMessage |
Show Timeout |
Show Event |
Show Unique |
Show Event |
Show PollFd |
Show State |
Show IOCallback |
Show FdKey |
Show FdData |
Show FD |
Show HandlePosn |
Show Fixity |
Show ConstrRep |
Show DataRep |
Show Constr |
Show DataType |
Show Timeout |
Show Version |
Show Exception |
Show a => Show [a] |
Integral a => Show (Ratio a) |
Show (Ptr a) |
Show (FunPtr a) |
Show a => Show ([::] a) |
Show a => Show (Maybe a) |
Show a => Show (Last a) |
Show a => Show (First a) |
Show a => Show (Product a) |
Show a => Show (Sum a) |
Show a => Show (Dual a) |
Show (ForeignPtr a) |
Show a => Show (IntMap a) |
Show a => Show (Sequ a) |
Show a => Show (LTree a) |
Show a => Show (PSQ a) |
Show a => Show (Elem a) |
RealFloat a => Show (Complex a) |
HasResolution a => Show (Fixed a) |
Show (a -> b) |
(Show a, Show b) => Show (Either a b) |
(Show a, Show b) => Show (a, b) |
Show (ST s a) |
(Ix a, Show a, Show b) => Show (Array a b) |
(Show a, Show b, Show c) => Show (a, b, c) |
(Show a, Show b, Show c, Show d) => Show (a, b, c, d) |
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) |
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |

shows :: Show a => a -> ShowS

equivalent to `showsPrec` with a precedence of 0.

showChar :: Char -> ShowS

utility function converting a `Char` to a show function that simply prepends the character unchanged.

showString :: String -> ShowS

utility function converting a `String` to a show function that simply prepends the string unchanged.

showParen :: Bool -> ShowS -> ShowS

utility function that surrounds the inner show function with parentheses when the `Bool` parameter is `True`.

showListWith :: (a -> ShowS) -> [a] -> ShowS

Show a list (using square brackets and commas), given a function for showing elements.