Text.Show.Pretty

pretty-show-1.6.13: Tools for working with derived `Show` instances and generic inspection of values.

Copyright | (c) Iavor S. Diatchki 2009
License | MIT
Maintainer | iavor.diatchki@gmail.com
Stability | provisional
Portability | Haskell 98
Safe Haskell | Safe
Language | Haskell98

Text.Show.Pretty

Contents

- Generic representation of values
- Values using the `Show` class
- Values using the `PrettyVal` class
- Rendering values to Html
- Get location of data files
- Deprecated

Description

Functions for human-readable derived `Show` instances.

Synopsis

- data Value
  - = Con Name [Value]
  - | InfixCons Value [(Name, Value)]
  - | Rec Name [(Name, Value)]
  - | Tuple [Value]
  - | List [Value]
  - | Neg Value
  - | Ratio Value Value
  - | Integer String
  - | Float String
  - | Char String
  - | String String
- type Name = String
- valToStr :: Value -> String
- valToDoc :: Value -> Doc
- valToHtmlPage :: HtmlOpts -> Value -> String
- parseValue :: String -> Maybe Value
- reify :: Show a => a -> Maybe Value
- ppDoc :: Show a => a -> Doc
- ppShow :: Show a => a -> String
- pPrint :: Show a => a -> IO ()
- dumpDoc :: PrettyVal a => a -> Doc
- dumpStr :: PrettyVal a => a -> String
- class PrettyVal a where
- valToHtml :: HtmlOpts -> Value -> Html
- data HtmlOpts = HtmlOpts {
  - dataDir :: FilePath
  - wideListWidth :: Int
  }
- defaultHtmlOpts :: HtmlOpts
- htmlPage :: HtmlOpts -> Html -> String
- newtype Html = Html {
  - exportHtml :: String
  }
- getDataDir :: IO FilePath
- ppValue :: Value -> Doc

# Generic representation of values

data Value #

Generic Haskell values. `NaN` and `Infinity` are represented as constructors. The `String` in the literals is the text for the literals "as is".

A chain of infix constructors means that they appeared in the input string without parentheses, i.e

`1 :+: 2 :*: 3` is represented with `InfixCons 1 [(":+:",2),(":*:",3)]`, whereas

`1 :+: (2 :*: 3)` is represented with `InfixCons 1 [(":+:",InfixCons 2 [(":*:",3)])]`.

Constructors

Con Name [Value] | Data constructor
InfixCons Value [(Name, Value)] | Infix data constructor chain
Rec Name [(Name, Value)] | Record value
Tuple [Value] | Tuple
List [Value] | List
Neg Value | Negated value
Ratio Value Value | Rational
Integer String | Non-negative integer
Float String | Non-negative floating num.
Char String | Character
String String | String

Instances

Eq Value # |
Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Show Value # |
Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #

type Name = String #

A name.

valToStr :: Value -> String #

Pretty print a generic value. Our intention is that the result is equivalent to the `Show` instance for the original value, except possibly easier to understand by a human.

valToDoc :: Value -> Doc #

Pretty print a generic value. Our intention is that the result is equivalent to the `Show` instance for the original value, except possibly easier to understand by a human.

valToHtmlPage :: HtmlOpts -> Value -> String #

Make an Html page representing the given value.

# Values using the `Show` class

parseValue :: String -> Maybe Value #

reify :: Show a => a -> Maybe Value #

ppDoc :: Show a => a -> Doc #

Try to show a value, prettily. If we do not understand the value, then we just use its standard `Show` instance.

ppShow :: Show a => a -> String #

Convert a generic value into a pretty `String`, if possible.

pPrint :: Show a => a -> IO () #

Pretty print a generic value to stdout. This is particularly useful in the GHCi interactive environment.

# Values using the `PrettyVal` class

dumpDoc :: PrettyVal a => a -> Doc #

Render a value in the `PrettyVal` class to a `Doc`. The benefit of this function is that `PrettyVal` instances may be derived automatically using generics.

dumpStr :: PrettyVal a => a -> String #

Render a value in the `PrettyVal` class to a `String`. The benefit of this function is that `PrettyVal` instances may be derived automatically using generics.

class PrettyVal a where #

A class for types that may be reified into a value. Instances of this class may be derived automatically, for datatypes that support `Generics`.

Methods

prettyVal :: a -> Value #

prettyVal :: (GDump (Rep a), Generic a) => a -> Value #

Instances

PrettyVal Bool # |
Methods prettyVal :: Bool -> Value # listValue :: [Bool] -> Value
PrettyVal Char # |
Methods prettyVal :: Char -> Value # listValue :: [Char] -> Value
PrettyVal Double # |
Methods prettyVal :: Double -> Value # listValue :: [Double] -> Value
PrettyVal Float # |
Methods prettyVal :: Float -> Value # listValue :: [Float] -> Value
PrettyVal Int # |
Methods prettyVal :: Int -> Value # listValue :: [Int] -> Value
PrettyVal Int8 # |
Methods prettyVal :: Int8 -> Value # listValue :: [Int8] -> Value
PrettyVal Int16 # |
Methods prettyVal :: Int16 -> Value # listValue :: [Int16] -> Value
PrettyVal Int32 # |
Methods prettyVal :: Int32 -> Value # listValue :: [Int32] -> Value
PrettyVal Int64 # |
Methods prettyVal :: Int64 -> Value # listValue :: [Int64] -> Value
PrettyVal Integer # |
Methods prettyVal :: Integer -> Value # listValue :: [Integer] -> Value
PrettyVal Ordering # |
Methods prettyVal :: Ordering -> Value # listValue :: [Ordering] -> Value
PrettyVal Word8 # |
Methods prettyVal :: Word8 -> Value # listValue :: [Word8] -> Value
PrettyVal Word16 # |
Methods prettyVal :: Word16 -> Value # listValue :: [Word16] -> Value
PrettyVal Word32 # |
Methods prettyVal :: Word32 -> Value # listValue :: [Word32] -> Value
PrettyVal Word64 # |
Methods prettyVal :: Word64 -> Value # listValue :: [Word64] -> Value
PrettyVal a => PrettyVal [a] # |
Methods prettyVal :: [a] -> Value # listValue :: [[a]] -> Value
PrettyVal a => PrettyVal (Maybe a) # |
Methods prettyVal :: Maybe a -> Value # listValue :: [Maybe a] -> Value
(PrettyVal a, Integral a) => PrettyVal (Ratio a) # |
Methods prettyVal :: Ratio a -> Value # listValue :: [Ratio a] -> Value
(PrettyVal a, PrettyVal b) => PrettyVal (Either a b) # |
Methods prettyVal :: Either a b -> Value # listValue :: [Either a b] -> Value
(PrettyVal a1, PrettyVal a2) => PrettyVal (a1, a2) # |
Methods prettyVal :: (a1, a2) -> Value # listValue :: [(a1, a2)] -> Value
(PrettyVal a1, PrettyVal a2, PrettyVal a3) => PrettyVal (a1, a2, a3) # |
Methods prettyVal :: (a1, a2, a3) -> Value # listValue :: [(a1, a2, a3)] -> Value
(PrettyVal a1, PrettyVal a2, PrettyVal a3, PrettyVal a4) => PrettyVal (a1, a2, a3, a4) # |
Methods prettyVal :: (a1, a2, a3, a4) -> Value # listValue :: [(a1, a2, a3, a4)] -> Value
(PrettyVal a1, PrettyVal a2, PrettyVal a3, PrettyVal a4, PrettyVal a5) => PrettyVal (a1, a2, a3, a4, a5) # |
Methods prettyVal :: (a1, a2, a3, a4, a5) -> Value # listValue :: [(a1, a2, a3, a4, a5)] -> Value
(PrettyVal a1, PrettyVal a2, PrettyVal a3, PrettyVal a4, PrettyVal a5, PrettyVal a6) => PrettyVal (a1, a2, a3, a4, a5, a6) # |
Methods prettyVal :: (a1, a2, a3, a4, a5, a6) -> Value # listValue :: [(a1, a2, a3, a4, a5, a6)] -> Value
(PrettyVal a1, PrettyVal a2, PrettyVal a3, PrettyVal a4, PrettyVal a5, PrettyVal a6, PrettyVal a7) => PrettyVal (a1, a2, a3, a4, a5, a6, a7) # |
Methods prettyVal :: (a1, a2, a3, a4, a5, a6, a7) -> Value # listValue :: [(a1, a2, a3, a4, a5, a6, a7)] -> Value

# Rendering values to Html

valToHtml :: HtmlOpts -> Value -> Html #

Convert a value into an Html fragment.

data HtmlOpts #

Options on how to generate Html (more to come).

Constructors

HtmlOpts |
Fields dataDir :: FilePath Path for extra files. If empty, we look in directory `style`, relative to document. wideListWidth :: Int Max. number of columns in wide lists.

Instances

Show HtmlOpts # |
Methods showsPrec :: Int -> HtmlOpts -> ShowS # show :: HtmlOpts -> String # showList :: [HtmlOpts] -> ShowS #

defaultHtmlOpts :: HtmlOpts #

Default options.

htmlPage :: HtmlOpts -> Html -> String #

Wrap an Html fragment to make an Html page.

newtype Html #

Constructors

Html |
Fields exportHtml :: String

# Get location of data files

getDataDir :: IO FilePath #

# Deprecated

ppValue :: Value -> Doc #

Deprecated: Please use `valToDoc` instead.