base-4.9.0.0: Basic libraries

Copyright(c) The University of Glasgow 2001
LicenseBSD-style (see the file libraries/base/LICENSE)
Maintainerlibraries@haskell.org
Stabilityprovisional
Portabilityportable
Safe HaskellSafe
LanguageHaskell2010

Text.Show

Description

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

Synopsis

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

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 :: Int -> a -> 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:

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 

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Show Char 

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Show Int 

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Show Int8 

Methods

showsPrec :: Int -> Int8 -> ShowS

show :: Int8 -> String

showList :: [Int8] -> ShowS

Show Int16 

Methods

showsPrec :: Int -> Int16 -> ShowS

show :: Int16 -> String

showList :: [Int16] -> ShowS

Show Int32 

Methods

showsPrec :: Int -> Int32 -> ShowS

show :: Int32 -> String

showList :: [Int32] -> ShowS

Show Int64 

Methods

showsPrec :: Int -> Int64 -> ShowS

show :: Int64 -> String

showList :: [Int64] -> ShowS

Show Integer 
Show Ordering 
Show Word 

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Show Word8 

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Show Word16 
Show Word32 
Show Word64 
Show TypeRep 
Show () 

Methods

showsPrec :: Int -> () -> ShowS

show :: () -> String

showList :: [()] -> ShowS

Show Module 
Show TrName 
Show TyCon 

Methods

showsPrec :: Int -> TyCon -> ShowS

show :: TyCon -> String

showList :: [TyCon] -> ShowS

Show SomeException 
Show GeneralCategory 
Show Number 
Show Lexeme 
Show SomeSymbol 
Show SomeNat 
Show DecidedStrictness 
Show SourceStrictness 
Show SourceUnpackedness 
Show Associativity 
Show Fixity 
Show Any 

Methods

showsPrec :: Int -> Any -> ShowS

show :: Any -> String

showList :: [Any] -> ShowS

Show All 

Methods

showsPrec :: Int -> All -> ShowS

show :: All -> String

showList :: [All] -> ShowS

Show IOMode 
Show Fingerprint 
Show CUIntMax 
Show CIntMax 
Show CUIntPtr 
Show CIntPtr 
Show CSUSeconds 
Show CUSeconds 
Show CTime 

Methods

showsPrec :: Int -> CTime -> ShowS

show :: CTime -> String

showList :: [CTime] -> ShowS

Show CClock 
Show CSigAtomic 
Show CWchar 
Show CSize 

Methods

showsPrec :: Int -> CSize -> ShowS

show :: CSize -> String

showList :: [CSize] -> ShowS

Show CPtrdiff 
Show CDouble 
Show CFloat 
Show CULLong 
Show CLLong 
Show CULong 
Show CLong 

Methods

showsPrec :: Int -> CLong -> ShowS

show :: CLong -> String

showList :: [CLong] -> ShowS

Show CUInt 

Methods

showsPrec :: Int -> CUInt -> ShowS

show :: CUInt -> String

showList :: [CUInt] -> ShowS

Show CInt 

Methods

showsPrec :: Int -> CInt -> ShowS

show :: CInt -> String

showList :: [CInt] -> ShowS

Show CUShort 
Show CShort 
Show CUChar 
Show CSChar 
Show CChar 

Methods

showsPrec :: Int -> CChar -> ShowS

show :: CChar -> String

showList :: [CChar] -> ShowS

Show IntPtr 
Show WordPtr 
Show ArithException 
Show ErrorCall 
Show Dynamic 
Show IOException 
Show MaskingState 
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 AllocationLimitExceeded 
Show Deadlock 
Show BlockedIndefinitelyOnSTM 
Show BlockedIndefinitelyOnMVar 
Show CodingFailureMode 
Show Fd 

Methods

showsPrec :: Int -> Fd -> ShowS

show :: Fd -> String

showList :: [Fd] -> ShowS

Show CRLim 

Methods

showsPrec :: Int -> CRLim -> ShowS

show :: CRLim -> String

showList :: [CRLim] -> ShowS

Show CTcflag 
Show CSpeed 
Show CCc 

Methods

showsPrec :: Int -> CCc -> ShowS

show :: CCc -> String

showList :: [CCc] -> ShowS

Show CUid 

Methods

showsPrec :: Int -> CUid -> ShowS

show :: CUid -> String

showList :: [CUid] -> ShowS

Show CNlink 
Show CGid 

Methods

showsPrec :: Int -> CGid -> ShowS

show :: CGid -> String

showList :: [CGid] -> ShowS

Show CSsize 
Show CPid 

Methods

showsPrec :: Int -> CPid -> ShowS

show :: CPid -> String

showList :: [CPid] -> ShowS

Show COff 

Methods

showsPrec :: Int -> COff -> ShowS

show :: COff -> String

showList :: [COff] -> ShowS

Show CMode 

Methods

showsPrec :: Int -> CMode -> ShowS

show :: CMode -> String

showList :: [CMode] -> ShowS

Show CIno 

Methods

showsPrec :: Int -> CIno -> ShowS

show :: CIno -> String

showList :: [CIno] -> ShowS

Show CDev 

Methods

showsPrec :: Int -> CDev -> ShowS

show :: CDev -> String

showList :: [CDev] -> ShowS

Show Lifetime 
Show Event 

Methods

showsPrec :: Int -> Event -> ShowS

show :: Event -> String

showList :: [Event] -> ShowS

Show ThreadStatus 
Show BlockReason 
Show ThreadId 
Show NestedAtomically 
Show NonTermination 
Show TypeError 
Show NoMethodError 
Show RecUpdError 
Show RecConError 
Show RecSelError 
Show PatternMatchFail 
Show FdKey 

Methods

showsPrec :: Int -> FdKey -> ShowS

show :: FdKey -> String

showList :: [FdKey] -> ShowS

Show HandlePosn 
Show GCStats 
Show Version 
Show Fixity 
Show ConstrRep 
Show DataRep 
Show Constr 
Show DataType 
Show Natural 
Show RTSFlags 
Show TickyFlags 
Show TraceFlags 
Show DoTrace 
Show ProfFlags 
Show DoHeapProfile 
Show CCFlags 
Show DoCostCentres 
Show DebugFlags 
Show MiscFlags 
Show ConcFlags 
Show GCFlags 
Show GiveGCStats 
Show StaticPtrInfo 
Show Void 

Methods

showsPrec :: Int -> Void -> ShowS

show :: Void -> String

showList :: [Void] -> ShowS

Show a => Show [a] 

Methods

showsPrec :: Int -> [a] -> ShowS

show :: [a] -> String

showList :: [[a]] -> ShowS

Show a => Show (Maybe a) 

Methods

showsPrec :: Int -> Maybe a -> ShowS

show :: Maybe a -> String

showList :: [Maybe a] -> ShowS

Show a => Show (Ratio a) 

Methods

showsPrec :: Int -> Ratio a -> ShowS

show :: Ratio a -> String

showList :: [Ratio a] -> ShowS

Show (Ptr a) 

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Show (FunPtr a) 

Methods

showsPrec :: Int -> FunPtr a -> ShowS

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

Show (U1 p) 

Methods

showsPrec :: Int -> U1 p -> ShowS

show :: U1 p -> String

showList :: [U1 p] -> ShowS

Show p => Show (Par1 p) 

Methods

showsPrec :: Int -> Par1 p -> ShowS

show :: Par1 p -> String

showList :: [Par1 p] -> ShowS

Show a => Show (Down a) 

Methods

showsPrec :: Int -> Down a -> ShowS

show :: Down a -> String

showList :: [Down a] -> ShowS

Show a => Show (Last a) 

Methods

showsPrec :: Int -> Last a -> ShowS

show :: Last a -> String

showList :: [Last a] -> ShowS

Show a => Show (First a) 

Methods

showsPrec :: Int -> First a -> ShowS

show :: First a -> String

showList :: [First a] -> ShowS

Show a => Show (Product a) 

Methods

showsPrec :: Int -> Product a -> ShowS

show :: Product a -> String

showList :: [Product a] -> ShowS

Show a => Show (Sum a) 

Methods

showsPrec :: Int -> Sum a -> ShowS

show :: Sum a -> String

showList :: [Sum a] -> ShowS

Show a => Show (Dual a) 

Methods

showsPrec :: Int -> Dual a -> ShowS

show :: Dual a -> String

showList :: [Dual a] -> ShowS

Show (ForeignPtr a) 
Show a => Show (ZipList a) 

Methods

showsPrec :: Int -> ZipList a -> ShowS

show :: ZipList a -> String

showList :: [ZipList a] -> ShowS

Show a => Show (Complex a) 

Methods

showsPrec :: Int -> Complex a -> ShowS

show :: Complex a -> String

showList :: [Complex a] -> ShowS

HasResolution a => Show (Fixed a) 

Methods

showsPrec :: Int -> Fixed a -> ShowS

show :: Fixed a -> String

showList :: [Fixed a] -> ShowS

Show a => Show (NonEmpty a) 

Methods

showsPrec :: Int -> NonEmpty a -> ShowS

show :: NonEmpty a -> String

showList :: [NonEmpty a] -> ShowS

Show a => Show (Option a) 

Methods

showsPrec :: Int -> Option a -> ShowS

show :: Option a -> String

showList :: [Option a] -> ShowS

Show m => Show (WrappedMonoid m) 
Show a => Show (Last a) 

Methods

showsPrec :: Int -> Last a -> ShowS

show :: Last a -> String

showList :: [Last a] -> ShowS

Show a => Show (First a) 

Methods

showsPrec :: Int -> First a -> ShowS

show :: First a -> String

showList :: [First a] -> ShowS

Show a => Show (Max a) 

Methods

showsPrec :: Int -> Max a -> ShowS

show :: Max a -> String

showList :: [Max a] -> ShowS

Show a => Show (Min a) 

Methods

showsPrec :: Int -> Min a -> ShowS

show :: Min a -> String

showList :: [Min a] -> ShowS

Show a => Show (Identity a)

This instance would be equivalent to the derived instances of the Identity newtype if the runIdentity field were removed

Methods

showsPrec :: Int -> Identity a -> ShowS

show :: Identity a -> String

showList :: [Identity a] -> ShowS

(Show a, Show b) => Show (Either a b) 

Methods

showsPrec :: Int -> Either a b -> ShowS

show :: Either a b -> String

showList :: [Either a b] -> ShowS

Show (f p) => Show (Rec1 f p) 

Methods

showsPrec :: Int -> Rec1 f p -> ShowS

show :: Rec1 f p -> String

showList :: [Rec1 f p] -> ShowS

Show (URec Char _p) 

Methods

showsPrec :: Int -> URec Char _p -> ShowS

show :: URec Char _p -> String

showList :: [URec Char _p] -> ShowS

Show (URec Double _p) 

Methods

showsPrec :: Int -> URec Double _p -> ShowS

show :: URec Double _p -> String

showList :: [URec Double _p] -> ShowS

Show (URec Float _p) 

Methods

showsPrec :: Int -> URec Float _p -> ShowS

show :: URec Float _p -> String

showList :: [URec Float _p] -> ShowS

Show (URec Int _p) 

Methods

showsPrec :: Int -> URec Int _p -> ShowS

show :: URec Int _p -> String

showList :: [URec Int _p] -> ShowS

Show (URec Word _p) 

Methods

showsPrec :: Int -> URec Word _p -> ShowS

show :: URec Word _p -> String

showList :: [URec Word _p] -> ShowS

(Show a, Show b) => Show (a, b) 

Methods

showsPrec :: Int -> (a, b) -> ShowS

show :: (a, b) -> String

showList :: [(a, b)] -> ShowS

Show (ST s a) 

Methods

showsPrec :: Int -> ST s a -> ShowS

show :: ST s a -> String

showList :: [ST s a] -> ShowS

Show (Proxy k s) 

Methods

showsPrec :: Int -> Proxy k s -> ShowS

show :: Proxy k s -> String

showList :: [Proxy k s] -> ShowS

(Show a, Show b) => Show (Arg a b) 

Methods

showsPrec :: Int -> Arg a b -> ShowS

show :: Arg a b -> String

showList :: [Arg a b] -> ShowS

Show c => Show (K1 i c p) 

Methods

showsPrec :: Int -> K1 i c p -> ShowS

show :: K1 i c p -> String

showList :: [K1 i c p] -> ShowS

(Show (f p), Show (g p)) => Show ((:+:) f g p) 

Methods

showsPrec :: Int -> (f :+: g) p -> ShowS

show :: (f :+: g) p -> String

showList :: [(f :+: g) p] -> ShowS

(Show (f p), Show (g p)) => Show ((:*:) f g p) 

Methods

showsPrec :: Int -> (f :*: g) p -> ShowS

show :: (f :*: g) p -> String

showList :: [(f :*: g) p] -> ShowS

Show (f (g p)) => Show ((:.:) f g p) 

Methods

showsPrec :: Int -> (f :.: g) p -> ShowS

show :: (f :.: g) p -> String

showList :: [(f :.: g) p] -> ShowS

(Show a, Show b, Show c) => Show (a, b, c) 

Methods

showsPrec :: Int -> (a, b, c) -> ShowS

show :: (a, b, c) -> String

showList :: [(a, b, c)] -> ShowS

Show ((:~:) k a b) 

Methods

showsPrec :: Int -> (k :~: a) b -> ShowS

show :: (k :~: a) b -> String

showList :: [(k :~: a) b] -> ShowS

Show (Coercion k a b) 

Methods

showsPrec :: Int -> Coercion k a b -> ShowS

show :: Coercion k a b -> String

showList :: [Coercion k a b] -> ShowS

Show (f a) => Show (Alt k f a) 

Methods

showsPrec :: Int -> Alt k f a -> ShowS

show :: Alt k f a -> String

showList :: [Alt k f a] -> ShowS

Show a => Show (Const k a b)

This instance would be equivalent to the derived instances of the Const newtype if the runConst field were removed

Methods

showsPrec :: Int -> Const k a b -> ShowS

show :: Const k a b -> String

showList :: [Const k a b] -> ShowS

Show (f p) => Show (M1 i c f p) 

Methods

showsPrec :: Int -> M1 i c f p -> ShowS

show :: M1 i c f p -> String

showList :: [M1 i c f p] -> ShowS

(Show a, Show b, Show c, Show d) => Show (a, b, c, d) 

Methods

showsPrec :: Int -> (a, b, c, d) -> ShowS

show :: (a, b, c, d) -> String

showList :: [(a, b, c, d)] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Product (TYPE Lifted) f g a) 

Methods

showsPrec :: Int -> Product (TYPE Lifted) f g a -> ShowS

show :: Product (TYPE Lifted) f g a -> String

showList :: [Product (TYPE Lifted) f g a] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Sum (TYPE Lifted) f g a) 

Methods

showsPrec :: Int -> Sum (TYPE Lifted) f g a -> ShowS

show :: Sum (TYPE Lifted) f g a -> String

showList :: [Sum (TYPE Lifted) f g a] -> ShowS

(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) 

Methods

showsPrec :: Int -> (a, b, c, d, e) -> ShowS

show :: (a, b, c, d, e) -> String

showList :: [(a, b, c, d, e)] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Compose (TYPE Lifted) (TYPE Lifted) f g a) 
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS

show :: (a, b, c, d, e, f) -> String

showList :: [(a, b, c, d, e, f)] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS

show :: (a, b, c, d, e, f, g) -> String

showList :: [(a, b, c, d, e, f, g)] -> ShowS

(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) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS

show :: (a, b, c, d, e, f, g, h) -> String

showList :: [(a, b, c, d, e, f, g, h)] -> ShowS

(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) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS

show :: (a, b, c, d, e, f, g, h, i) -> String

showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS

(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) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS

(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) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS

(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) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS

(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) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS

(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) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS

(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) 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS

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.