Safe Haskell	Safe
Language	Haskell98

Formatting.Internal

Description

Internal format starters.

Synopsis

Documentation

newtype Format r a Source #

A formatter. When you construct formatters the first type parameter, r, will remain polymorphic. The second type parameter, a, will change to reflect the types of the data that will be formatted. For example, in

myFormat :: Formatter r (Text -> Int -> r)
myFormat = "Person's name is " % text % ", age is " % hex

the first type parameter remains polymorphic, and the second type parameter is Text -> Int -> r, which indicates that it formats a Text and an Int.

When you run the Format, for example with format, you provide the arguments and they will be formatted into a string.

> format ("Person's name is " % text % ", age is " % hex) "Dave" 54
"Person's name is Dave, age is 36"

Constructors

Format
Fields runFormat :: (Builder -> r) -> a

Instances

Functor (Format r) Source #	Not particularly useful, but could be.
Methods fmap :: (a -> b) -> Format r a -> Format r b # (<$) :: a -> Format r b -> Format r a #
Category * Format Source #	The same as (%). At present using `Category` has an import overhead, but one day it might be imported as standard.
Methods id :: cat a a # (.) :: cat b c -> cat a b -> cat a c #
(~) * a r => IsString (Format r a) Source #	Useful instance for writing format string. With this you can write `Foo` instead of `now "Foo!"`.
Methods fromString :: String -> Format r a #
Semigroup (Format r (a -> r)) Source #
Methods (<>) :: Format r (a -> r) -> Format r (a -> r) -> Format r (a -> r) # sconcat :: NonEmpty (Format r (a -> r)) -> Format r (a -> r) # stimes :: Integral b => b -> Format r (a -> r) -> Format r (a -> r) #
Monoid (Format r (a -> r)) Source #	Useful instance for applying two formatters to the same input argument. For example: `format (year <> "/" % month) now` will yield `"2015/01"`.
Methods mempty :: Format r (a -> r) # mappend :: Format r (a -> r) -> Format r (a -> r) -> Format r (a -> r) # mconcat :: [Format r (a -> r)] -> Format r (a -> r) #

(%) :: Format r a -> Format r' r -> Format r' a infixr 9 Source #

Concatenate two formatters.

formatter1 % formatter2 is a formatter that accepts arguments for formatter1 and formatter2 and concatenates their results. For example

format1 :: Format r (Text -> r)
format1 = "Person's name is " % text

format2 :: Format r r
format2 = ", "

format3 :: Format r (Int -> r)
format3 = "age is " % hex

myFormat :: Formatter r (Text -> Int -> r)
myFormat = format1 % format2 % format3

Notice how the argument types of format1 and format3 are gathered into the type of myFormat.

(This is actually the composition operator for Format's Category instance, but that is (at present) inconvenient to use with regular Prelude. So this function is provided as a convenience.)

(%.) :: Format r (Builder -> r') -> Format r' a -> Format r a infixr 8 Source #

Function compose two formatters. Will feed the result of one formatter into another.

now :: Builder -> Format r r Source #

Don't format any data, just output a constant Builder.

bind :: Format r a -> (Builder -> Format r' r) -> Format r' a Source #

Monadic indexed bind for holey monoids.

mapf :: (a -> b) -> Format r (b -> t) -> Format r (a -> t) Source #

Functorial map over a formatter's input. Example: format (mapf (drop 1) string) "hello"

later :: (a -> Builder) -> Format r (a -> r) Source #

Format a value of type a using a function of type a -> Builder. For example, later (f :: Int -> Builder) produces Format r (Int -> r).

format :: Format Text a -> a Source #

Run the formatter and return a lazy Text value.