Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- fmt :: Format Text a -> a
- sfmt :: Format String a -> a
- fstr :: Format r (String -> r)
- ftxt :: Format r (Text -> r)
- fint :: Integral a => Format r (a -> r)
- fcid :: Format r (CID -> r)
- fref :: Format r (Ref hash -> r)
- frefName :: Format r (RefName -> r)
- (%) :: Format r a -> Format r' r -> Format r' a
- shown :: Show a => Format r (a -> r)
- data Format r a
Documentation
(%) :: Format r a -> Format r' r -> Format r' a infixr 9 #
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.)
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"
Instances
Functor (Format r) | Not particularly useful, but could be. |
Category Format | The same as (%). At present using |
a ~ r => IsString (Format r a) | Useful instance for writing format string. With this you can
write |
Defined in Formatting.Internal fromString :: String -> Format r a # | |
Semigroup (Format r (a -> r)) | |
Monoid (Format r (a -> r)) | Useful instance for applying two formatters to the same input
argument. For example: |