blazeT-0.0.5: A true monad (transformer) version of the blaze-markup and blaze-html libraries

Safe HaskellNone
LanguageHaskell98

Text.BlazeT.Internal

Contents

Synopsis

Entities exported only by the blazeT version of this module

newtype MarkupT m a Source #

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

Constructors

MarkupT 

Instances

MonadTrans MarkupT Source # 

Methods

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

Monad m => MonadWriter Text.Blaze.Markup (MarkupT m) Source # 
Monad m => Monad (MarkupT m) Source # 

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) Source # 

Methods

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

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

Applicative m => Applicative (MarkupT m) Source # 

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 ()) Source # 

Methods

fromString :: String -> MarkupT m () #

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

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) Source # 

Methods

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

Monad m => Attributable (MarkupT m a) Source # 

Methods

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

mapMarkupT :: (m (a, Text.Blaze.Markup) -> n (b, Text.Blaze.Markup)) -> MarkupT m a -> MarkupT n b Source #

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

Specializations for blaze-markup backwards compatibility

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

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

Running

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

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

Executing

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

Wrappers

wrapMarkupT2 :: Monad m => (Text.Blaze.Markup -> Text.Blaze.Markup) -> MarkupT m a -> MarkupT m a Source #

Wrapper for functions that modify Text.Blaze.Markup is simply censor

Entities exported also by Text.Blaze.Internal

The following is an adaptation of all Text.Blaze.Internal exports to blazeT types.

Entities that are reexported from Text.Blaze.Internal have the original documentation attached to them.

Entities that had to be adapted are tagged with "(Adapted)". For their documentation consult the Text.Blaze.Internal documentation.

Important types.

data ChoiceString :: * #

A string denoting input from different string representations.

Constructors

Static ~StaticString

Static data

String String

A Haskell String

Text T.Text

A Text value

ByteString BS.ByteString

An encoded bytestring

PreEscaped ChoiceString

A pre-escaped string

External ChoiceString

External data in style/script tags, should be checked for validity

AppendChoiceString ChoiceString ChoiceString

Concatenation

EmptyChoiceString

Empty string

data StaticString :: * #

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

Constructors

StaticString 

Fields

data Tag :: * #

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

Instances

data Attribute :: * #

Type for an attribute.

Creating custom tags and attributes.

attribute #

Arguments

:: Tag

Raw key

-> Tag

Shared key string for the HTML attribute.

-> AttributeValue

Value for the HTML attribute.

-> Attribute

Resulting HTML attribute.

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

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"

Converting values to Markup.

unsafeLazyByteString Source #

Arguments

:: BL.ByteString

Value to insert

-> Markup

Resulting HTML fragment

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

Comments

Converting values to tags.

textTag #

Arguments

:: T.Text

Text to create a tag from

-> Tag

Resulting tag

Create a Tag from some T.Text.

stringTag #

Arguments

:: String

String to create a tag from

-> Tag

Resulting tag

Create a Tag from a String.

Converting values to attribute values.

textValue #

Arguments

:: T.Text

The actual value.

-> AttributeValue

Resulting attribute value.

Render an attribute value from T.Text.

preEscapedTextValue #

Arguments

:: T.Text

The actual value

-> AttributeValue

Resulting attribute value

Render an attribute value from T.Text without escaping.

lazyTextValue #

Arguments

:: LT.Text

The actual value

-> AttributeValue

Resulting attribute value

A variant of textValue for lazy LT.Text

preEscapedLazyTextValue #

Arguments

:: LT.Text

The actual value

-> AttributeValue

Resulting attribute value

A variant of preEscapedTextValue for lazy LT.Text

textBuilderValue #

Arguments

:: LTB.Builder

The actual value

-> AttributeValue

Resulting attribute value

A variant of textValue for text LTB.Builder

preEscapedTextBuilderValue #

Arguments

:: LTB.Builder

The actual value

-> AttributeValue

Resulting attribute value

A variant of preEscapedTextValue for text LTB.Builder

stringValue :: String -> AttributeValue #

Create an attribute value from a String.

preEscapedStringValue :: String -> AttributeValue #

Create an attribute value from a String without escaping.

unsafeByteStringValue #

Arguments

:: BS.ByteString

ByteString value

-> AttributeValue

Resulting attribute value

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

unsafeLazyByteStringValue #

Arguments

:: BL.ByteString

ByteString value

-> AttributeValue

Resulting attribute value

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

Setting attributes

class Attributable h where #

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

(!) :: 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"

Modifying Markup elements

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

external :: Monad m => MarkupT m a -> MarkupT m a Source #

Querying Markup elements

null :: Foldable t => forall a. t a -> Bool #

Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.