Text.BlazeT

DO NOT READ THIS. READ Text.BlazeT.Internal INSTEAD

Due due a Haddock bug, this documentation is misleading. Please read Text.BlazeT.Internal instead.

(The bug shows both Text.Blaze.Markup and Text.BlazeT.Markup as Markup.)

Use this documentation only to see which entities are exported by this module.

DO NOT READ THIS

type Markup = MarkupM ()

data Tag :: *

Type for an HTML tag. This can be seen as an internal string type used by BlazeMarkup.

Instances

IsString Tag

Methods

fromString :: String -> Tag

data Attribute :: *

Type for an attribute.

Instances

Monoid Attribute

Methods

mempty :: Attribute

mappend :: Attribute -> Attribute -> Attribute

mconcat :: [Attribute] -> Attribute

data AttributeValue :: *

The type for the value part of an attribute.

Instances

IsString AttributeValue

Methods

fromString :: String -> AttributeValue

Monoid AttributeValue

Methods

mempty :: AttributeValue

mappend :: AttributeValue -> AttributeValue -> AttributeValue

mconcat :: [AttributeValue] -> AttributeValue

ToValue AttributeValue

Methods

toValue :: AttributeValue -> AttributeValue

preEscapedToValue :: AttributeValue -> AttributeValue

dataAttribute

Arguments

:: Tag

Name of the attribute.

-> AttributeValue

Value for the attribute.

-> Attribute

Resulting HTML attribute.

From HTML 5 onwards, the user is able to specify custom data attributes.

An example:

<p data-foo="bar">Hello.</p>

We support this in BlazeMarkup using this function. The above fragment could be described using BlazeMarkup with:

p ! dataAttribute "foo" "bar" $ "Hello."

customAttribute

Arguments

:: Tag

Name of the attribute

-> AttributeValue

Value for the attribute

-> Attribute

Resulting HTML attribtue

Create a custom attribute. This is not specified in the HTML spec, but some JavaScript libraries rely on it.

An example:

<select dojoType="select">foo</select>

Can be produced using:

select ! customAttribute "dojoType" "select" $ "foo"

class ToMarkup a where

Minimal complete definition

toMarkup, preEscapedToMarkup

Methods

toMarkup :: a -> Markup

preEscapedToMarkup :: a -> Markup

Instances

ToMarkup a => ToMarkup a

Methods

toMarkup :: a -> Markup

preEscapedToMarkup :: a -> Markup

text :: Text -> Markup

preEscapedText :: Text -> Markup

lazyText :: Text -> Markup

preEscapedLazyText :: Text -> Markup

string :: String -> Markup

preEscapedString :: String -> Markup

unsafeByteString :: ByteString -> Markup

unsafeLazyByteString

Arguments

:: ByteString

Value to insert

-> Markup

Resulting HTML fragment

Insert a lazy ByteString. See unsafeByteString for reasons why this is an unsafe operation.

textComment :: Text -> Markup

lazyTextComment :: Text -> Markup

stringComment :: String -> Markup

unsafeByteStringComment :: ByteString -> Markup

unsafeLazyByteStringComment :: ByteString -> Markup

textTag

Arguments

:: Text

Text to create a tag from

-> Tag

Resulting tag

Create a Tag from some Text.

stringTag

Arguments

:: String

String to create a tag from

-> Tag

Resulting tag

Create a Tag from a String.

class ToValue a where

Class allowing us to use a single function for attribute values

Minimal complete definition

toValue

Instances

ToValue Bool

Methods

toValue :: Bool -> AttributeValue

preEscapedToValue :: Bool -> AttributeValue

ToValue Char

Methods

toValue :: Char -> AttributeValue

preEscapedToValue :: Char -> AttributeValue

ToValue Double

Methods

toValue :: Double -> AttributeValue

preEscapedToValue :: Double -> AttributeValue

ToValue Float

Methods

toValue :: Float -> AttributeValue

preEscapedToValue :: Float -> AttributeValue

ToValue Int

Methods

toValue :: Int -> AttributeValue

preEscapedToValue :: Int -> AttributeValue

ToValue Int32

Methods

toValue :: Int32 -> AttributeValue

preEscapedToValue :: Int32 -> AttributeValue

ToValue Int64

Methods

toValue :: Int64 -> AttributeValue

preEscapedToValue :: Int64 -> AttributeValue

ToValue Integer

Methods

toValue :: Integer -> AttributeValue

preEscapedToValue :: Integer -> AttributeValue

ToValue Word

Methods

toValue :: Word -> AttributeValue

preEscapedToValue :: Word -> AttributeValue

ToValue Word32

Methods

toValue :: Word32 -> AttributeValue

preEscapedToValue :: Word32 -> AttributeValue

ToValue Word64

Methods

toValue :: Word64 -> AttributeValue

preEscapedToValue :: Word64 -> AttributeValue

ToValue String

Methods

toValue :: String -> AttributeValue

preEscapedToValue :: String -> AttributeValue

ToValue Text

Methods

toValue :: Text -> AttributeValue

preEscapedToValue :: Text -> AttributeValue

ToValue Text

Methods

toValue :: Text -> AttributeValue

preEscapedToValue :: Text -> AttributeValue

ToValue AttributeValue

Methods

toValue :: AttributeValue -> AttributeValue

preEscapedToValue :: AttributeValue -> AttributeValue

ToValue Builder

Methods

toValue :: Builder -> AttributeValue

preEscapedToValue :: Builder -> AttributeValue

textValue

Arguments

:: Text

The actual value.

-> AttributeValue

Resulting attribute value.

Render an attribute value from Text.

preEscapedTextValue

Arguments

:: Text

The actual value

-> AttributeValue

Resulting attribute value

Render an attribute value from Text without escaping.

lazyTextValue

Arguments

:: Text

The actual value

-> AttributeValue

Resulting attribute value

A variant of textValue for lazy Text

preEscapedLazyTextValue

Arguments

:: Text

The actual value

-> AttributeValue

Resulting attribute value

A variant of preEscapedTextValue for lazy Text

stringValue :: String -> AttributeValue

Create an attribute value from a String.

preEscapedStringValue :: String -> AttributeValue

Create an attribute value from a String without escaping.

unsafeByteStringValue

Arguments

:: ByteString

ByteString value

-> AttributeValue

Resulting attribute value

Create an attribute value from a ByteString. See unsafeByteString for reasons why this might not be a good idea.

unsafeLazyByteStringValue

Arguments

:: ByteString

ByteString value

-> AttributeValue

Resulting attribute value

Create an attribute value from a lazy ByteString. See unsafeByteString for reasons why this might not be a good idea.

(!) :: Attributable h => h -> Attribute -> h

Apply an attribute to an element.

Example:

img ! src "foo.png"

Result:

<img src="foo.png" />

This can be used on nested elements as well.

Example:

p ! style "float: right" $ "Hello!"

Result:

<p style="float: right">Hello!</p>

(!?) :: Attributable h => h -> (Bool, Attribute) -> h

Shorthand for setting an attribute depending on a conditional.

Example:

p !? (isBig, A.class "big") $ "Hello"

Gives the same result as:

(if isBig then p ! A.class "big" else p) "Hello"

contents :: Monad m => MarkupT m a -> MarkupT m a

newtype MarkupT m a

Everything is build around the simple newtype definition of the MarkupT transformer, which makes use the Monoid instance of Blaze Markup and is simply a WriterT writing Blaze Markup:

Constructors

MarkupT

Fields

• fromMarkupT :: WriterT Markup m a

Instances

MonadTrans MarkupT

Methods

lift :: Monad m => m a -> MarkupT m a

Monad m => MonadWriter Markup (MarkupT m)

Methods

writer :: (a, Markup) -> MarkupT m a

tell :: Markup -> MarkupT m ()

listen :: MarkupT m a -> MarkupT m (a, Markup)

pass :: MarkupT m (a, Markup -> Markup) -> MarkupT m a

Monad m => Monad (MarkupT m)

Methods

(>>=) :: MarkupT m a -> (a -> MarkupT m b) -> MarkupT m b

(>>) :: MarkupT m a -> MarkupT m b -> MarkupT m b

return :: a -> MarkupT m a

fail :: String -> MarkupT m a

Functor m => Functor (MarkupT m)

Methods

fmap :: (a -> b) -> MarkupT m a -> MarkupT m b

(<$) :: a -> MarkupT m b -> MarkupT m a

Applicative m => Applicative (MarkupT m)

Methods

pure :: a -> MarkupT m a

(<*>) :: MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b

(*>) :: MarkupT m a -> MarkupT m b -> MarkupT m b

(<*) :: MarkupT m a -> MarkupT m b -> MarkupT m a

Monad m => IsString (MarkupT m ())

Methods

fromString :: String -> MarkupT m ()

(Monad m, Monoid a) => Monoid (MarkupT m a)

Methods

mempty :: MarkupT m a

mappend :: MarkupT m a -> MarkupT m a -> MarkupT m a

mconcat :: [MarkupT m a] -> MarkupT m a

Monad m => Attributable (a -> MarkupT m b)

Methods

(!) :: (a -> MarkupT m b) -> Attribute -> a -> MarkupT m b

Monad m => Attributable (MarkupT m a)

Methods

(!) :: MarkupT m a -> Attribute -> MarkupT m a

type MarkupI a = MarkupT Identity a

mapMarkupT :: (m (a, Markup) -> n (b, Markup)) -> MarkupT m a -> MarkupT n b

Map both the return value and markup of a computation using the given function

type MarkupM a = forall m. Monad m => MarkupT m a

type Markup2 = forall m. Monad m => MarkupT m () -> MarkupT m ()

runMarkupT :: MarkupT m a -> m (a, Markup)

runMarkup :: MarkupI a -> (a, Markup)

runWith :: Monad m => (MarkupI () -> c) -> MarkupT m a -> m (a, c)

run the MarkupT and return a pair consisting of the result of the computation and the blaze markup rendered with a blaze renderer like renderHtml

execMarkupT :: Monad m => MarkupT m a -> m Markup

execMarkup :: MarkupI a -> Markup

execWith :: Monad m => (MarkupI () -> c) -> MarkupT m a -> m c