Safe Haskell	None
Language	Haskell98

Lucid.Base

Contents

Rendering
Running
Combinators
Types
Classes

Description

Base types and combinators.

Synopsis

Rendering

renderText :: Html a -> Text #

Render the HTML to a lazy Text.

This is a convenience function defined in terms of execHtmlT, runIdentity and toLazyByteString, and decodeUtf8. Check the source if you're interested in the lower-level behaviour.

renderBS :: Html a -> ByteString #

Render the HTML to a lazy ByteString.

This is a convenience function defined in terms of execHtmlT, runIdentity and toLazyByteString. Check the source if you're interested in the lower-level behaviour.

renderTextT :: Monad m => HtmlT m a -> m Text #

Render the HTML to a lazy Text, but in a monad.

This is a convenience function defined in terms of execHtmlT and toLazyByteString, and decodeUtf8. Check the source if you're interested in the lower-level behaviour.

renderBST :: Monad m => HtmlT m a -> m ByteString #

Render the HTML to a lazy ByteString, but in a monad.

This is a convenience function defined in terms of execHtmlT and toLazyByteString. Check the source if you're interested in the lower-level behaviour.

renderToFile :: FilePath -> Html a -> IO () #

Render the HTML to a lazy ByteString.

This is a convenience function defined in terms of execHtmlT, runIdentity and toLazyByteString. Check the source if you're interested in the lower-level behaviour.

Running

execHtmlT #

Arguments

:: Monad m
=> HtmlT m a	The HTML to generate.
-> m Builder	The `a` is discarded.

Build the HTML. Analogous to execState.

You might want to use this is if you want to do something with the raw Builder. Otherwise for simple cases you can just use renderText or renderBS.

evalHtmlT #

Arguments

:: Monad m
=> HtmlT m a	HTML monad to evaluate.
-> m a	Ignore the HTML output and just return the value.

Evaluate the HTML to its return value. Analogous to evalState.

Use this if you want to ignore the HTML output of an action completely and just get the result.

For using with the Html type, you'll need runIdentity e.g.

>>> runIdentity (evalHtmlT (p_ "Hello!"))
()

relaxHtmlT #

Arguments

:: Monad m
=> HtmlT Identity a	The HTML generated purely.
-> HtmlT m a	Same HTML accessible in a polymorphic context.

Generalize the underlying monad.

Some builders are happy to deliver results in a pure underlying monad, here Identity, but have trouble maintaining the polymorphic type. This utility generalizes from Identity.

Combinators

makeElement #

Arguments

:: Monad m
=> Text	Name.
-> HtmlT m a	Children HTML.
-> HtmlT m a	A parent element.

Make an HTML builder.

makeElementNoEnd #

Arguments

:: Monad m
=> Text	Name.
-> HtmlT m ()	A parent element.

Make an HTML builder for elements which have no ending tag.

makeXmlElementNoEnd #

Arguments

:: Monad m
=> Text	Name.
-> HtmlT m ()	A parent element.

Make an XML builder for elements which have no ending tag.

makeAttribute #

Arguments

:: Text	Attribute name.
-> Text	Attribute value.
-> Attribute

Make an attribute builder.

Types

type Html = HtmlT Identity #

Simple HTML builder type. Defined in terms of HtmlT. Check out that type for instance information.

Simple use-cases will just use this type. But if you want to transformer over Reader or something, you can go and use HtmlT.

newtype HtmlT m a #

A monad transformer that generates HTML. Use the simpler Html type if you don't want to transform over some other monad.

Constructors

HtmlT
Fields runHtmlT :: m (HashMap Text Text -> Builder, a) This is the low-level way to run the HTML transformer, finally returning an element builder and a value. You can pass `mempty` for this argument for a top-level call. See `evalHtmlT` and `execHtmlT` for easier to use functions.

Instances

MFunctor HtmlT #
Methods hoist :: Monad m => (forall a. m a -> n a) -> HtmlT m b -> HtmlT n b #
MonadTrans HtmlT #	Used for `lift`.
Methods lift :: Monad m => m a -> HtmlT m a #
MonadReader r m => MonadReader r (HtmlT m) #
Methods ask :: HtmlT m r # local :: (r -> r) -> HtmlT m a -> HtmlT m a # reader :: (r -> a) -> HtmlT m a #
MonadState s m => MonadState s (HtmlT m) #
Methods get :: HtmlT m s # put :: s -> HtmlT m () # state :: (s -> (a, s)) -> HtmlT m a #
(Monad m, (~) * a ()) => TermRaw Text (HtmlT m a) #	Given children immediately, just use that and expect no attributes.
Methods termRaw :: Text -> Text -> HtmlT m a # termRawWith :: Text -> [Attribute] -> Text -> HtmlT m a #
Monad m => Monad (HtmlT m) #	Basically acts like Writer.
Methods (>>=) :: HtmlT m a -> (a -> HtmlT m b) -> HtmlT m b # (>>) :: HtmlT m a -> HtmlT m b -> HtmlT m b # return :: a -> HtmlT m a # fail :: String -> HtmlT m a #
Monad m => Functor (HtmlT m) #	Just re-uses Monad.
Methods fmap :: (a -> b) -> HtmlT m a -> HtmlT m b # (<$) :: a -> HtmlT m b -> HtmlT m a #
Monad m => Applicative (HtmlT m) #	Based on the monad instance.
Methods pure :: a -> HtmlT m a # (<>) :: HtmlT m (a -> b) -> HtmlT m a -> HtmlT m b # (>) :: HtmlT m a -> HtmlT m b -> HtmlT m b # (<*) :: HtmlT m a -> HtmlT m b -> HtmlT m a #
MonadIO m => MonadIO (HtmlT m) #	If you want to use IO in your HTML generation.
Methods liftIO :: IO a -> HtmlT m a #
(Monad m, ToHtml f, (~) * a ()) => TermRaw [Attribute] (f -> HtmlT m a) #	Given attributes, expect more child input.
Methods termRaw :: Text -> [Attribute] -> f -> HtmlT m a # termRawWith :: Text -> [Attribute] -> [Attribute] -> f -> HtmlT m a #
(Monad m, (~) * f (HtmlT m a)) => Term [Attribute] (f -> HtmlT m a) #	Given attributes, expect more child input.
Methods term :: Text -> [Attribute] -> f -> HtmlT m a # termWith :: Text -> [Attribute] -> [Attribute] -> f -> HtmlT m a #
(~) (* -> *) m Identity => Show (HtmlT m a) #	Just calls `renderText`.
Methods showsPrec :: Int -> HtmlT m a -> ShowS # show :: HtmlT m a -> String # showList :: [HtmlT m a] -> ShowS #
(Monad m, (~) * a ()) => IsString (HtmlT m a) #	We pack it via string. Could possibly encode straight into a builder. That might be faster.
Methods fromString :: String -> HtmlT m a #
((~) * a (), Monad m) => Semigroup (HtmlT m a) #
Methods (<>) :: HtmlT m a -> HtmlT m a -> HtmlT m a # sconcat :: NonEmpty (HtmlT m a) -> HtmlT m a # stimes :: Integral b => b -> HtmlT m a -> HtmlT m a #
((~) * a (), Monad m) => Monoid (HtmlT m a) #	Monoid is right-associative, a la the `Builder` in it.
Methods mempty :: HtmlT m a # mappend :: HtmlT m a -> HtmlT m a -> HtmlT m a # mconcat :: [HtmlT m a] -> HtmlT m a #
Monad m => With (HtmlT m a -> HtmlT m a) #	For the contentful elements: `div_`
Methods with :: (HtmlT m a -> HtmlT m a) -> [Attribute] -> HtmlT m a -> HtmlT m a #
Monad m => With (HtmlT m a) #	For the contentless elements: `br_`
Methods with :: HtmlT m a -> [Attribute] -> HtmlT m a #
((~) * a (), (~) (* -> *) m Identity) => ToHtml (HtmlT m a) #
Methods toHtml :: Monad m => HtmlT m a -> HtmlT m () # toHtmlRaw :: Monad m => HtmlT m a -> HtmlT m () #
Monad m => Term (HtmlT m a) (HtmlT m a) #	Given children immediately, just use that and expect no attributes.
Methods term :: Text -> HtmlT m a -> HtmlT m a # termWith :: Text -> [Attribute] -> HtmlT m a -> HtmlT m a #

data Attribute #

A simple attribute. Don't use the constructor, use makeAttribute.

Constructors

Attribute !Text !Text

Instances

Eq Attribute #
Methods (==) :: Attribute -> Attribute -> Bool # (/=) :: Attribute -> Attribute -> Bool #
Show Attribute #
Methods showsPrec :: Int -> Attribute -> ShowS # show :: Attribute -> String # showList :: [Attribute] -> ShowS #
Hashable Attribute #
Methods hashWithSalt :: Int -> Attribute -> Int # hash :: Attribute -> Int #
TermRaw Text Attribute #	Some termRaws (like `style_`, `title_`) can be used for attributes as well as elements.
Methods termRaw :: Text -> Text -> Attribute # termRawWith :: Text -> [Attribute] -> Text -> Attribute #
Term Text Attribute #	Some terms (like `style_`, `title_`) can be used for attributes as well as elements.
Methods term :: Text -> Text -> Attribute # termWith :: Text -> [Attribute] -> Text -> Attribute #
(Monad m, ToHtml f, (~) * a ()) => TermRaw [Attribute] (f -> HtmlT m a) #	Given attributes, expect more child input.
Methods termRaw :: Text -> [Attribute] -> f -> HtmlT m a # termRawWith :: Text -> [Attribute] -> [Attribute] -> f -> HtmlT m a #
(Monad m, (~) * f (HtmlT m a)) => Term [Attribute] (f -> HtmlT m a) #	Given attributes, expect more child input.
Methods term :: Text -> [Attribute] -> f -> HtmlT m a # termWith :: Text -> [Attribute] -> [Attribute] -> f -> HtmlT m a #

Classes

class Term arg result | result -> arg where #

Used to construct HTML terms.

Simplest use: p_ = term "p" yields p_.

Very overloaded for three cases:

The first case is the basic arg of [(Text,Text)] which will return a function that wants children.
The second is an arg which is HtmlT m (), in which case the term accepts no attributes and just the children are used for the element.
Finally, this is also used for overloaded attributes, like style_ or title_. If a return type of (Text,Text) is inferred then an attribute will be made.

The instances look intimidating but actually the constraints make it very general so that type inference works well even in the presence of things like OverloadedLists and such.

Minimal complete definition

termWith

Methods

term :: Text -> arg -> result #

Used for constructing elements e.g. term "p" yields p_.

termWith :: Text -> [Attribute] -> arg -> result #

Use this if you want to make an element which inserts some pre-prepared attributes into the element.

Instances

Term Text Attribute #	Some terms (like `style_`, `title_`) can be used for attributes as well as elements.
Methods term :: Text -> Text -> Attribute # termWith :: Text -> [Attribute] -> Text -> Attribute #
(Monad m, (~) * f (HtmlT m a)) => Term [Attribute] (f -> HtmlT m a) #	Given attributes, expect more child input.
Methods term :: Text -> [Attribute] -> f -> HtmlT m a # termWith :: Text -> [Attribute] -> [Attribute] -> f -> HtmlT m a #
Monad m => Term (HtmlT m a) (HtmlT m a) #	Given children immediately, just use that and expect no attributes.
Methods term :: Text -> HtmlT m a -> HtmlT m a # termWith :: Text -> [Attribute] -> HtmlT m a -> HtmlT m a #

class TermRaw arg result | result -> arg where #

Same as the Term class, but will not HTML escape its children. Useful for elements like style_ or script_.

Minimal complete definition

termRawWith

Methods

termRaw :: Text -> arg -> result #

Used for constructing elements e.g. termRaw "p" yields p_.

termRawWith :: Text -> [Attribute] -> arg -> result #

Use this if you want to make an element which inserts some pre-prepared attributes into the element.

Instances

TermRaw Text Attribute #	Some termRaws (like `style_`, `title_`) can be used for attributes as well as elements.
Methods termRaw :: Text -> Text -> Attribute # termRawWith :: Text -> [Attribute] -> Text -> Attribute #
(Monad m, (~) * a ()) => TermRaw Text (HtmlT m a) #	Given children immediately, just use that and expect no attributes.
Methods termRaw :: Text -> Text -> HtmlT m a # termRawWith :: Text -> [Attribute] -> Text -> HtmlT m a #
(Monad m, ToHtml f, (~) * a ()) => TermRaw [Attribute] (f -> HtmlT m a) #	Given attributes, expect more child input.
Methods termRaw :: Text -> [Attribute] -> f -> HtmlT m a # termRawWith :: Text -> [Attribute] -> [Attribute] -> f -> HtmlT m a #

class ToHtml a where #

Can be converted to HTML.

Minimal complete definition

toHtml, toHtmlRaw

Methods

toHtml :: Monad m => a -> HtmlT m () #

toHtmlRaw :: Monad m => a -> HtmlT m () #

Instances

ToHtml String #
Methods toHtml :: Monad m => String -> HtmlT m () # toHtmlRaw :: Monad m => String -> HtmlT m () #
ToHtml ByteString #	This instance requires the ByteString to contain UTF-8 encoded text, for the `toHtml` method. The `toHtmlRaw` method doesn't care, but the overall HTML rendering methods in this module assume UTF-8.
Methods toHtml :: Monad m => ByteString -> HtmlT m () # toHtmlRaw :: Monad m => ByteString -> HtmlT m () #
ToHtml ByteString #	This instance requires the ByteString to contain UTF-8 encoded text, for the `toHtml` method. The `toHtmlRaw` method doesn't care, but the overall HTML rendering methods in this module assume UTF-8.
Methods toHtml :: Monad m => ByteString -> HtmlT m () # toHtmlRaw :: Monad m => ByteString -> HtmlT m () #
ToHtml Text #
Methods toHtml :: Monad m => Text -> HtmlT m () # toHtmlRaw :: Monad m => Text -> HtmlT m () #
ToHtml Text #
Methods toHtml :: Monad m => Text -> HtmlT m () # toHtmlRaw :: Monad m => Text -> HtmlT m () #
((~) * a (), (~) (* -> *) m Identity) => ToHtml (HtmlT m a) #
Methods toHtml :: Monad m => HtmlT m a -> HtmlT m () # toHtmlRaw :: Monad m => HtmlT m a -> HtmlT m () #

class With a where #

With an element use these attributes. An overloaded way of adding attributes either to an element accepting attributes-and-children or one that just accepts attributes. See the two instances.

Minimal complete definition

with

Methods

with :: a -> [Attribute] -> a #

With the given element(s), use the given attributes.

Instances

Monad m => With (HtmlT m a -> HtmlT m a) #	For the contentful elements: `div_`
Methods with :: (HtmlT m a -> HtmlT m a) -> [Attribute] -> HtmlT m a -> HtmlT m a #
Monad m => With (HtmlT m a) #	For the contentless elements: `br_`
Methods with :: HtmlT m a -> [Attribute] -> HtmlT m a #