base-4.7.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 | portable
Safe Haskell | Safe
Language | Haskell2010

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 `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)"`.

Minimal complete definition

showsPrec | show

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 `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.

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 SomeException |
Show Number |
Show Lexeme |
Show Fingerprint |
Show TyCon |
Show TypeRep |
Show Associativity |
Show Fixity |
Show Arity |
Show Any |
Show All |
Show ArithException |
Show ErrorCall |
Show IOException |
Show MaskingState |
Show Dynamic |
Show CUIntMax |
Show CIntMax |
Show CUIntPtr |
Show CIntPtr |
Show CSUSeconds |
Show CUSeconds |
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 GeneralCategory |
Show IntPtr |
Show WordPtr |
Show CodingProgress |
Show TextEncoding |
Show SeekMode |
Show NewlineMode |
Show Newline |
Show BufferMode |
Show Handle |
Show IOErrorType |
Show ExitCode |
Show ArrayException |
Show AsyncException |
Show SomeAsyncException |
Show AssertionFailed |
Show Deadlock |
Show BlockedIndefinitelyOnSTM |
Show BlockedIndefinitelyOnMVar |
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 CodingFailureMode |
Show ThreadStatus |
Show BlockReason |
Show ThreadId |
Show NestedAtomically |
Show NonTermination |
Show NoMethodError |
Show RecUpdError |
Show RecConError |
Show RecSelError |
Show PatternMatchFail |
Show IOMode |
Show Event |
Show FdKey |
Show HandlePosn |
Show TyCon |
Show TypeRep |
Show SomeSymbol |
Show SomeNat |
Show Version |
Show Fixity |
Show ConstrRep |
Show DataRep |
Show Constr |
Show DataType |
Show GCStats |
Show a => Show [a] |
(Integral a, Show a) => Show (Ratio a) |
Show (Ptr a) |
Show (FunPtr a) |
Show (U1 p) |
Show p => Show (Par1 p) |
Show a => Show (Maybe a) |
Show a => Show (Down 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 (ZipList a) |
Show a => Show (Complex a) |
HasResolution a => Show (Fixed a) |
Show (a -> b) |
(Show a, Show b) => Show (Either a b) |
Show (f p) => Show (Rec1 f p) |
(Show a, Show b) => Show (a, b) |
Show (ST s a) |
Show (Proxy k s) |
Show c => Show (K1 i c p) |
(Show (f p), Show (g p)) => Show ((:+:) f g p) |
(Show (f p), Show (g p)) => Show ((:*:) f g p) |
Show (f (g p)) => Show ((:.:) f g p) |
(Show a, Show b, Show c) => Show (a, b, c) |
Show ((:~:) k a b) |
Show (Coercion k a b) |
Show (f p) => Show (M1 i c f p) |
(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.