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:

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

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

Wrapper for Markup is simply tell

Wrapper for functions that modify Markup is simply censor

A string denoting input from different string representations.

A static string that supports efficient output to all possible backends.

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

Type for an attribute.

The type for the value part of an attribute.

Create an HTML attribute that can be applied to an HTML element later using the ! operator.

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."

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"

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

Create a Tag from some ChoiceString.

Create a Tag from a ChoiceString.

Render an attribute value from ChoiceString.

Render an attribute value from ChoiceString without escaping.

A variant of textValue for lazy Text

A variant of preEscapedTextValue for lazy Text

A variant of textValue for text Builder

A variant of preEscapedTextValue for text Builder

Create an attribute value from a ChoiceString.

Create an attribute value from a ChoiceString without escaping.

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

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

Used for applying attributes. You should not define your own instances of this class.

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>

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"

Test whether the structure is empty. The default implementation is Left-associative and lazy in both the initial element and the accumulator. Thus optimised for structures where the first element can be accessed in constant time. Structures where this is not the case should have a non-default implementation.

Examples

>>> null []
True

>>> null [1]
False

>>> null [1..]
False

Since: base-4.8.0.0