Portability | Non-portable (type synonym instances) |
---|---|

Stability | Experimental |

Maintainer | Dan Doel |

Safe Haskell | None |

Efficiently convert from values to lazy byte strings.

- class Show a where
- show :: Show a => a -> ByteString
- putAscii :: Char -> Put
- putUTF8 :: Char -> Put
- putAsciiStr :: String -> Put
- putUTF8Str :: String -> Put
- unsafePutDigit :: Int -> Put
- putDigit :: Int -> Put
- showpIntAtBase :: Integral a => a -> (Int -> Char) -> a -> Put
- showpGFloat :: RealFloat a => Maybe Int -> a -> Put
- showpFFloat :: RealFloat a => Maybe Int -> a -> Put
- showpEFloat :: RealFloat a => Maybe Int -> a -> Put
- unlinesP :: [Put] -> Put
- unwordsP :: [Put] -> Put
- showpParen :: Bool -> Put -> Put
- print :: Show a => a -> IO ()
- type Put = PutM ()
- newtype PutM a = Put {
- unPut :: PairS a

- runPut :: Put -> ByteString

# The Show class

showpPrec :: Int -> a -> PutSource

Encodes a value to an efficient byte string builder. The precedence is used to determine where to put parentheses in a shown expression involving operators.

Values of type Put can be efficiently combined, so the showp functions are available for showing multiple values before producing an output byte string.

Encodes a value to an efficient byte string builder. Values of type Put can be efficiently combined, so this is available for building strings from multiple values.

Allows for specialized display of lists of values. This is used, for example, when showing arrays of Chars.

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 Put | |

Show a => Show [a] | |

(Show a, Integral a) => Show (Ratio a) | |

(Show a, RealFloat a) => Show (Complex a) | |

Show a => Show (Maybe a) | |

Show e => Show (Set e) | |

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

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

(Show i, Show e, Ix i) => Show (Array i e) | |

(Show k, Show v) => Show (Map k v) | |

(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 :: Show a => a -> ByteStringSource

Encode a single value into a byte string

# Putting Chars

# Putting Strings

putAsciiStr :: String -> PutSource

Writes a string of ascii characters to a byte string

putUTF8Str :: String -> PutSource

Writes a string of unicode characters to a byte string, properly UTF-8 encoded

# Putting digits

unsafePutDigit :: Int -> PutSource

Puts the decimal digit corresponding to the given Int without checking that it is in the interval [0,9]

# Putting integers

showpIntAtBase :: Integral a => a -> (Int -> Char) -> a -> PutSource

Shows an Integral number using the base specified by the first argument and the chracter representation specified by the second.

# Putting floats

showpGFloat :: RealFloat a => Maybe Int -> a -> PutSource

Show a signed RealFloat value using decimal notation when the absolute value lies between 0.1 and 9,999,999, and scientific notation otherwise. The optional integer can be used to specify precision.

showpFFloat :: RealFloat a => Maybe Int -> a -> PutSource

Show a signed RealFloat value using decimal notation. The optional integer can be used to specify precision.

showpEFloat :: RealFloat a => Maybe Int -> a -> PutSource

Show a signed RealFloat value using scientific (exponential) notation. The optional integer can be used to specify precision.

# Combining builders

showpParen :: Bool -> Put -> PutSource

A utility function for surrounding output by parentheses conditionally.

# Printing values

# Put

newtype PutM a

The PutM type. A Writer monad over the efficient Builder monoid.

runPut :: Put -> ByteString

Run the `Put`

monad with a serialiser