Safe Haskell | None |
---|---|
Language | Haskell98 |
Clear to write, read and edit DSL for writing HTML
- renderText :: Html a -> Text
- renderBS :: Html a -> ByteString
- renderTextT :: Monad m => HtmlT m a -> m Text
- renderBST :: Monad m => HtmlT m a -> m ByteString
- execHtmlT :: Monad m => HtmlT m a -> m Builder
- evalHtmlT :: Monad m => HtmlT m a -> m a
- runHtmlT :: HtmlT m a -> m (Builder -> Builder -> Builder, a)
- type Html = HtmlT Identity
- data Attr = Attr {}
- class ToText a where
- class ToHtml a where
- class Mixed a r where
- class With a where
- module Lucid.Html5
Intro
HTML terms in Lucid are written with a postfix ‘_
’ to indicate data
rather than code. Some examples:
See Lucid.Html5 for a complete list of Html5 combinators.
Plain text is written using the OverloadedStrings
and
ExtendedDefaultRules
extensions, and is automatically escaped:
>>>
"123 < 456" :: Html ()
123 < 456
Elements nest by function application:
>>>
table_ (tr_ (td_ (p_ "Hello, World!")))
<table><tr><td><p>Hello, World!</p></td></tr></table>
Elements are juxtaposed via monoidal append:
>>>
p_ "hello" <> p_ "sup"
<p>hello</p><p>sup</p>
Or monadic sequencing:
>>>
div_ (do p_ "hello"; p_ "sup")
<div><p>hello</p><p>sup</p></div>
Attributes are set using the with
combinator:
>>>
with p_ [class_ "brand"] "Lucid Inc"
<p class="brand">Lucid Inc</p>
Here is a fuller example of Lucid:
with table_ [rows_ "2"] (tr_ (do with td_ [class_ "top",colspan_ "2"] (p_ "Hello, attributes!") td_ "yay!"))
For proper rendering you can easily run some HTML immediately with:
>>>
renderText (p_ "Hello!")
> "<p>Hello!</p>"
>>>
renderBS (with p_ [style_ "color:red"] "Hello!")
"<p style=\"color:red\">Hello!</p>"
For ease of use in GHCi, there is a Show
instance, as
demonstrated above.
renderText :: Html a -> Text Source
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 Source
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 Source
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 Source
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.
Running
If the above rendering functions aren't suited for your purpose,
you can run the monad directly and use the more low-level blaze
Builder
, which has a plethora of output modes in
Blaze.ByteString.Builder.
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
.
:: 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!"))
()
Combinators
Types
An attribute.
Classes
Can be converted to HTML.
Used for names that are mixed, e.g. style_
.
With an element use these attributes.
:: a | Some element, either |
-> [Attr] | |
-> a |
With the given element(s), use the given attributes.
Re-exports
module Lucid.Html5