2 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
3 {-# OPTIONS_HADDOCK hide #-}
4 -----------------------------------------------------------------------------
7 -- Copyright : (c) The University of Glasgow, 1992-2002
8 -- License : see libraries/base/LICENSE
10 -- Maintainer : cvs-ghc@haskell.org
11 -- Stability : internal
12 -- Portability : non-portable (GHC Extensions)
14 -- The 'Show' class, and related operations.
16 -----------------------------------------------------------------------------
23 -- Instances for Show: (), [], Bool, Ordering, Int, Char
26 shows, showChar, showString, showParen, showList__, showSpace,
27 showLitChar, protectEsc,
28 intToDigit, showSignedInt,
31 -- Character operations
38 import GHC.List ( (!!), foldr1
39 #ifdef USE_REPORT_PRELUDE
47 %*********************************************************
49 \subsection{The @Show@ class}
51 %*********************************************************
54 -- | The @shows@ functions return a function that prepends the
55 -- output 'String' to an existing 'String'. This allows constant-time
56 -- concatenation of results using function composition.
57 type ShowS = String -> String
59 -- | Conversion of values to readable 'String's.
61 -- Minimal complete definition: 'showsPrec' or 'show'.
63 -- Derived instances of 'Show' have the following properties, which
64 -- are compatible with derived instances of 'Text.Read.Read':
66 -- * The result of 'show' is a syntactically correct Haskell
67 -- expression containing only constants, given the fixity
68 -- declarations in force at the point where the type is declared.
69 -- It contains only the constructor names defined in the data type,
70 -- parentheses, and spaces. When labelled constructor fields are
71 -- used, braces, commas, field names, and equal signs are also used.
73 -- * If the constructor is defined to be an infix operator, then
74 -- 'showsPrec' will produce infix applications of the constructor.
76 -- * the representation will be enclosed in parentheses if the
77 -- precedence of the top-level constructor in @x@ is less than @d@
78 -- (associativity is ignored). Thus, if @d@ is @0@ then the result
79 -- is never surrounded in parentheses; if @d@ is @11@ it is always
80 -- surrounded in parentheses, unless it is an atomic expression.
82 -- * If the constructor is defined using record syntax, then 'show'
83 -- will produce the record-syntax form, with the fields given in the
84 -- same order as the original declaration.
86 -- For example, given the declarations
89 -- > data Tree a = Leaf a | Tree a :^: Tree a
91 -- the derived instance of 'Show' is equivalent to
93 -- > instance (Show a) => Show (Tree a) where
95 -- > showsPrec d (Leaf m) = showParen (d > app_prec) $
96 -- > showString "Leaf " . showsPrec (app_prec+1) m
97 -- > where app_prec = 10
99 -- > showsPrec d (u :^: v) = showParen (d > up_prec) $
100 -- > showsPrec (up_prec+1) u .
101 -- > showString " :^: " .
102 -- > showsPrec (up_prec+1) v
103 -- > where up_prec = 5
105 -- Note that right-associativity of @:^:@ is ignored. For example,
107 -- * @'show' (Leaf 1 :^: Leaf 2 :^: Leaf 3)@ produces the string
108 -- @\"Leaf 1 :^: (Leaf 2 :^: Leaf 3)\"@.
111 -- | Convert a value to a readable 'String'.
113 -- 'showsPrec' should satisfy the law
115 -- > showsPrec d x r ++ s == showsPrec d x (r ++ s)
117 -- Derived instances of 'Text.Read.Read' and 'Show' satisfy the following:
119 -- * @(x,\"\")@ is an element of
120 -- @('Text.Read.readsPrec' d ('showsPrec' d x \"\"))@.
122 -- That is, 'Text.Read.readsPrec' parses the string produced by
123 -- 'showsPrec', and delivers the value that 'showsPrec' started with.
125 showsPrec :: Int -- ^ the operator precedence of the enclosing
126 -- context (a number from @0@ to @11@).
127 -- Function application has precedence @10@.
128 -> a -- ^ the value to be converted to a 'String'
131 -- | A specialised variant of 'showsPrec', using precedence context
132 -- zero, and returning an ordinary 'String'.
135 -- | The method 'showList' is provided to allow the programmer to
136 -- give a specialised way of showing lists of values.
137 -- For example, this is used by the predefined 'Show' instance of
138 -- the 'Char' type, where values of type 'String' should be shown
139 -- in double quotes, rather than between square brackets.
140 showList :: [a] -> ShowS
142 showsPrec _ x s = show x ++ s
144 showList ls s = showList__ shows ls s
146 showList__ :: (a -> ShowS) -> [a] -> ShowS
147 showList__ _ [] s = "[]" ++ s
148 showList__ showx (x:xs) s = '[' : showx x (showl xs)
151 showl (y:ys) = ',' : showx y (showl ys)
153 appPrec, appPrec1 :: Int
154 -- Use unboxed stuff because we don't have overloaded numerics yet
155 appPrec = I# 10# -- Precedence of application:
156 -- one more than the maximum operator precedence of 9
157 appPrec1 = I# 11# -- appPrec + 1
160 %*********************************************************
162 \subsection{Simple Instances}
164 %*********************************************************
168 instance Show () where
169 showsPrec _ () = showString "()"
171 instance Show a => Show [a] where
172 showsPrec _ = showList
174 instance Show Bool where
175 showsPrec _ True = showString "True"
176 showsPrec _ False = showString "False"
178 instance Show Ordering where
179 showsPrec _ LT = showString "LT"
180 showsPrec _ EQ = showString "EQ"
181 showsPrec _ GT = showString "GT"
183 instance Show Char where
184 showsPrec _ '\'' = showString "'\\''"
185 showsPrec _ c = showChar '\'' . showLitChar c . showChar '\''
187 showList cs = showChar '"' . showl cs
188 where showl "" s = showChar '"' s
189 showl ('"':xs) s = showString "\\\"" (showl xs s)
190 showl (x:xs) s = showLitChar x (showl xs s)
191 -- Making 's' an explicit parameter makes it clear to GHC
192 -- that showl has arity 2, which avoids it allocating an extra lambda
193 -- The sticking point is the recursive call to (showl xs), which
194 -- it can't figure out would be ok with arity 2.
196 instance Show Int where
197 showsPrec = showSignedInt
199 instance Show a => Show (Maybe a) where
200 showsPrec _p Nothing s = showString "Nothing" s
201 showsPrec p (Just x) s
202 = (showParen (p > appPrec) $
204 showsPrec appPrec1 x) s
208 %*********************************************************
210 \subsection{Show instances for the first few tuples
212 %*********************************************************
215 -- The explicit 's' parameters are important
216 -- Otherwise GHC thinks that "shows x" might take a lot of work to compute
217 -- and generates defns like
218 -- showsPrec _ (x,y) = let sx = shows x; sy = shows y in
219 -- \s -> showChar '(' (sx (showChar ',' (sy (showChar ')' s))))
221 instance (Show a, Show b) => Show (a,b) where
222 showsPrec _ (a,b) s = show_tuple [shows a, shows b] s
224 instance (Show a, Show b, Show c) => Show (a, b, c) where
225 showsPrec _ (a,b,c) s = show_tuple [shows a, shows b, shows c] s
227 instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d) where
228 showsPrec _ (a,b,c,d) s = show_tuple [shows a, shows b, shows c, shows d] s
230 instance (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) where
231 showsPrec _ (a,b,c,d,e) s = show_tuple [shows a, shows b, shows c, shows d, shows e] s
233 instance (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a,b,c,d,e,f) where
234 showsPrec _ (a,b,c,d,e,f) s = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f] s
236 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g)
237 => Show (a,b,c,d,e,f,g) where
238 showsPrec _ (a,b,c,d,e,f,g) s
239 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g] s
241 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h)
242 => Show (a,b,c,d,e,f,g,h) where
243 showsPrec _ (a,b,c,d,e,f,g,h) s
244 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h] s
246 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i)
247 => Show (a,b,c,d,e,f,g,h,i) where
248 showsPrec _ (a,b,c,d,e,f,g,h,i) s
249 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
252 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j)
253 => Show (a,b,c,d,e,f,g,h,i,j) where
254 showsPrec _ (a,b,c,d,e,f,g,h,i,j) s
255 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
258 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k)
259 => Show (a,b,c,d,e,f,g,h,i,j,k) where
260 showsPrec _ (a,b,c,d,e,f,g,h,i,j,k) s
261 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
262 shows i, shows j, shows k] s
264 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k,
266 => Show (a,b,c,d,e,f,g,h,i,j,k,l) where
267 showsPrec _ (a,b,c,d,e,f,g,h,i,j,k,l) s
268 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
269 shows i, shows j, shows k, shows l] s
271 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k,
273 => Show (a,b,c,d,e,f,g,h,i,j,k,l,m) where
274 showsPrec _ (a,b,c,d,e,f,g,h,i,j,k,l,m) s
275 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
276 shows i, shows j, shows k, shows l, shows m] s
278 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k,
279 Show l, Show m, Show n)
280 => Show (a,b,c,d,e,f,g,h,i,j,k,l,m,n) where
281 showsPrec _ (a,b,c,d,e,f,g,h,i,j,k,l,m,n) s
282 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
283 shows i, shows j, shows k, shows l, shows m, shows n] s
285 instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k,
286 Show l, Show m, Show n, Show o)
287 => Show (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) where
288 showsPrec _ (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) s
289 = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
290 shows i, shows j, shows k, shows l, shows m, shows n, shows o] s
292 show_tuple :: [ShowS] -> ShowS
293 show_tuple ss = showChar '('
294 . foldr1 (\s r -> s . showChar ',' . r) ss
299 %*********************************************************
301 \subsection{Support code for @Show@}
303 %*********************************************************
306 -- | equivalent to 'showsPrec' with a precedence of 0.
307 shows :: (Show a) => a -> ShowS
308 shows = showsPrec zeroInt
310 -- | utility function converting a 'Char' to a show function that
311 -- simply prepends the character unchanged.
312 showChar :: Char -> ShowS
315 -- | utility function converting a 'String' to a show function that
316 -- simply prepends the string unchanged.
317 showString :: String -> ShowS
320 -- | utility function that surrounds the inner show function with
321 -- parentheses when the 'Bool' parameter is 'True'.
322 showParen :: Bool -> ShowS -> ShowS
323 showParen b p = if b then showChar '(' . p . showChar ')' else p
326 showSpace = {-showChar ' '-} \ xs -> ' ' : xs
329 Code specific for characters
332 -- | Convert a character to a string using only printable characters,
333 -- using Haskell source-language escape conventions. For example:
335 -- > showLitChar '\n' s = "\\n" ++ s
337 showLitChar :: Char -> ShowS
338 showLitChar c s | c > '\DEL' = showChar '\\' (protectEsc isDec (shows (ord c)) s)
339 showLitChar '\DEL' s = showString "\\DEL" s
340 showLitChar '\\' s = showString "\\\\" s
341 showLitChar c s | c >= ' ' = showChar c s
342 showLitChar '\a' s = showString "\\a" s
343 showLitChar '\b' s = showString "\\b" s
344 showLitChar '\f' s = showString "\\f" s
345 showLitChar '\n' s = showString "\\n" s
346 showLitChar '\r' s = showString "\\r" s
347 showLitChar '\t' s = showString "\\t" s
348 showLitChar '\v' s = showString "\\v" s
349 showLitChar '\SO' s = protectEsc (== 'H') (showString "\\SO") s
350 showLitChar c s = showString ('\\' : asciiTab!!ord c) s
351 -- I've done manual eta-expansion here, becuase otherwise it's
352 -- impossible to stop (asciiTab!!ord) getting floated out as an MFE
354 isDec c = c >= '0' && c <= '9'
356 protectEsc :: (Char -> Bool) -> ShowS -> ShowS
357 protectEsc p f = f . cont
358 where cont s@(c:_) | p c = "\\&" ++ s
363 asciiTab = -- Using an array drags in the array module. listArray ('\NUL', ' ')
364 ["NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
365 "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
366 "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
367 "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US",
371 Code specific for Ints.
374 -- | Convert an 'Int' in the range @0@..@15@ to the corresponding single
375 -- digit 'Char'. This function fails on other inputs, and generates
376 -- lower-case hexadecimal digits.
377 intToDigit :: Int -> Char
379 | i >=# 0# && i <=# 9# = unsafeChr (ord '0' `plusInt` I# i)
380 | i >=# 10# && i <=# 15# = unsafeChr (ord 'a' `minusInt` ten `plusInt` I# i)
381 | otherwise = error ("Char.intToDigit: not a digit " ++ show (I# i))
385 showSignedInt :: Int -> Int -> ShowS
386 showSignedInt (I# p) (I# n) r
387 | n <# 0# && p ># 6# = '(' : itos n (')' : r)
388 | otherwise = itos n r
390 itos :: Int# -> String -> String
393 let I# minInt# = minInt in
395 -- negateInt# minInt overflows, so we can't do that:
396 then '-' : itos' (negateInt# (n# `quotInt#` 10#))
397 (itos' (negateInt# (n# `remInt#` 10#)) cs)
398 else '-' : itos' (negateInt# n#) cs
399 | otherwise = itos' n# cs
401 itos' :: Int# -> String -> String
403 | n# <# 10# = C# (chr# (ord# '0'# +# n#)) : cs
404 | otherwise = case chr# (ord# '0'# +# (n# `remInt#` 10#)) of { c# ->
405 itos' (n# `quotInt#` 10#) (C# c# : cs) }