-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A fast and nice HTML templating library with distinct compilation/rendering phases.
--   
--   A fast and nice HTML templating library with distinct
--   compilation/rendering phases.
@package nice-html
@version 0.3.0

module Text.Html.Nice.Internal
type AttrName = Text
data Attr a
(:=) :: !AttrName -> !Text -> Attr a
[attrKey] :: Attr a -> !AttrName
[attrVal] :: Attr a -> !Text
(:-) :: !AttrName -> a -> Attr a
[attrKey] :: Attr a -> !AttrName
[attrValHole] :: Attr a -> a
data IsEscaped
DoEscape :: IsEscaped
Don'tEscape :: IsEscaped
data SomeText
LazyT :: Text -> SomeText
BuilderT :: Builder -> SomeText
StrictT :: !Text -> SomeText

-- | A very simple HTML DSL
data Markup' a
Doctype :: Markup' a
Node :: !Text -> !(Vector (Attr a)) -> (Markup' a) -> Markup' a
VoidNode :: !Text -> !(Vector (Attr a)) -> Markup' a
List :: [Markup' a] -> Markup' a
Stream :: (Stream a) -> Markup' a
Text :: !IsEscaped -> !SomeText -> Markup' a
Hole :: !IsEscaped -> a -> Markup' a
Empty :: Markup' a
data Stream a
ListS :: [s] -> !(FastMarkup (s -> a)) -> Stream a

-- | Don't use this! It's a lie!
unstream :: (FastMarkup a -> b) -> Stream a -> (b -> c -> c) -> c -> c
data (:$) a b
(:$) :: (FastMarkup (a -> b)) -> a -> (:$) a b
data FastMarkup a
Bunch :: {-# UNPACK #-} !(Vector (FastMarkup a)) -> FastMarkup a
FStream :: !(Stream a) -> FastMarkup a
FHole :: !IsEscaped -> !a -> FastMarkup a
FLText :: Text -> FastMarkup a
FSText :: {-# UNPACK #-} !Text -> FastMarkup a
FBuilder :: !Builder -> FastMarkup a
FEmpty :: FastMarkup a
FDeep :: (FastMarkup (FastMarkup a)) -> FastMarkup a
data Markup'F (a_aeR5 :: Type) r_ah4P
DoctypeF :: Markup'F r_ah4P
NodeF :: !Text -> !(Vector (Attr a_aeR5)) -> r_ah4P -> Markup'F r_ah4P
VoidNodeF :: !Text -> !(Vector (Attr a_aeR5)) -> Markup'F r_ah4P
ListF :: [r_ah4P] -> Markup'F r_ah4P
StreamF :: (Stream a_aeR5) -> Markup'F r_ah4P
TextF :: !IsEscaped -> !SomeText -> Markup'F r_ah4P
HoleF :: !IsEscaped -> a_aeR5 -> Markup'F r_ah4P
EmptyF :: Markup'F r_ah4P

-- | Unlike <tt>plate</tt>, this uses <a>Monad</a>. That's because
--   <a>traverse</a> over <a>Vector</a> is really quite slow.
plateFM :: Monad m => (FastMarkup a -> m (FastMarkup a)) -> FastMarkup a -> m (FastMarkup a)
compileAttrs :: forall a. Vector (Attr a) -> (Builder, Vector (Attr a))
escapeText :: Text -> Builder
escape :: SomeText -> Builder
toText :: Builder -> Text
fastAttr :: Attr a -> FastMarkup a
fast :: Markup' a -> FastMarkup a

-- | Look for an immediate string-like term and render that
immediateRender :: FastMarkup a -> Maybe Builder

-- | Flatten a vector of 'FastMarkup. String-like terms that are next to
--   eachother should be combined
munch :: Vector (FastMarkup a) -> Vector (FastMarkup a)

-- | Recursively flatten <a>FastMarkup</a> until doing so does nothing
flatten :: FastMarkup a -> FastMarkup a

-- | Run all Text builders
strictify :: FastMarkup a -> FastMarkup a

-- | Compile <tt>Markup''</tt>
compile_ :: Markup' a -> FastMarkup a
recompile :: FastMarkup a -> FastMarkup a
unlayer :: FastMarkup (FastMarkup a) -> FastMarkup a

-- | Render <a>FastMarkup</a>
renderM :: Monad m => (a -> m Builder) -> FastMarkup a -> m Builder

-- | Render <a>FastMarkup</a> by recursively rendering any sub-markup.
renderMs :: Monad m => (a -> m (FastMarkup Void)) -> FastMarkup a -> m Builder

-- | Render <a>FastMarkup</a> that has no holes.
render :: FastMarkup Void -> Builder
class Render a m
r :: Render a m => a -> m Builder

-- | Defer application of an argument to rendering
newtype RenderToFastMarkup a
RenderToFastMarkup :: a -> RenderToFastMarkup a
[unToFastMarkup] :: RenderToFastMarkup a -> a
class ToFastMarkup a
toFastMarkup :: ToFastMarkup a => a -> FastMarkup b
newtype AsDecimal a
AsDecimal :: a -> AsDecimal a
[asDecimal] :: AsDecimal a -> a
newtype AsHex a
AsHex :: a -> AsHex a
[asHex] :: AsHex a -> a
newtype AsRealFloat a
AsRealFloat :: a -> AsRealFloat a
[asRealFloat] :: AsRealFloat a -> a
instance Data.Bifunctor.Bifunctor Text.Html.Nice.Internal.Markup'F
instance (Text.Html.Nice.Internal.Render b m, m' ~ Control.Monad.Trans.Reader.ReaderT a m) => Text.Html.Nice.Internal.Render (a -> b) m'
instance (GHC.Base.Monad m, Text.Html.Nice.Internal.Render b m) => Text.Html.Nice.Internal.Render (a Text.Html.Nice.Internal.:$ b) m
instance GHC.Base.Monad m => Text.Html.Nice.Internal.Render Data.Void.Void m
instance GHC.Base.Monad m => Text.Html.Nice.Internal.Render Data.Text.Internal.Builder.Builder m
instance GHC.Base.Monad m => Text.Html.Nice.Internal.Render Data.Text.Internal.Text m
instance GHC.Base.Monad m => Text.Html.Nice.Internal.Render Data.Text.Internal.Lazy.Text m
instance (Text.Html.Nice.Internal.Render a m, GHC.Base.Monad m) => Text.Html.Nice.Internal.Render (Text.Html.Nice.Internal.FastMarkup a) m
instance (Text.Html.Nice.Internal.ToFastMarkup a, GHC.Base.Monad m) => Text.Html.Nice.Internal.Render (Text.Html.Nice.Internal.RenderToFastMarkup a) m
instance Text.Html.Nice.Internal.ToFastMarkup Data.Text.Internal.Text
instance Text.Html.Nice.Internal.ToFastMarkup Data.Text.Internal.Lazy.Text
instance Text.Html.Nice.Internal.ToFastMarkup Data.Text.Internal.Builder.Builder
instance GHC.Real.Integral a => Text.Html.Nice.Internal.ToFastMarkup (Text.Html.Nice.Internal.AsDecimal a)
instance GHC.Real.Integral a => Text.Html.Nice.Internal.ToFastMarkup (Text.Html.Nice.Internal.AsHex a)
instance GHC.Float.RealFloat a => Text.Html.Nice.Internal.ToFastMarkup (Text.Html.Nice.Internal.AsRealFloat a)
instance Data.Traversable.Traversable (Text.Html.Nice.Internal.Markup'F a0)
instance Data.Foldable.Foldable (Text.Html.Nice.Internal.Markup'F a0)
instance GHC.Base.Functor (Text.Html.Nice.Internal.Markup'F a0)
instance Data.Functor.Foldable.Recursive (Text.Html.Nice.Internal.Markup' a0)
instance Data.Functor.Foldable.Corecursive (Text.Html.Nice.Internal.Markup' a0)
instance Data.Foldable.Foldable Text.Html.Nice.Internal.Markup'
instance GHC.Base.Functor Text.Html.Nice.Internal.Markup'
instance GHC.Classes.Eq a => GHC.Classes.Eq (Text.Html.Nice.Internal.Markup' a)
instance GHC.Show.Show a => GHC.Show.Show (Text.Html.Nice.Internal.Markup' a)
instance GHC.Base.Functor ((Text.Html.Nice.Internal.:$) a)
instance GHC.Generics.Generic (Text.Html.Nice.Internal.FastMarkup a)
instance Data.Foldable.Foldable Text.Html.Nice.Internal.FastMarkup
instance GHC.Base.Functor Text.Html.Nice.Internal.FastMarkup
instance GHC.Classes.Eq a => GHC.Classes.Eq (Text.Html.Nice.Internal.FastMarkup a)
instance GHC.Show.Show a => GHC.Show.Show (Text.Html.Nice.Internal.FastMarkup a)
instance GHC.Classes.Eq Text.Html.Nice.Internal.SomeText
instance GHC.Show.Show Text.Html.Nice.Internal.SomeText
instance GHC.Classes.Eq Text.Html.Nice.Internal.IsEscaped
instance GHC.Show.Show Text.Html.Nice.Internal.IsEscaped
instance Data.Traversable.Traversable Text.Html.Nice.Internal.Attr
instance Data.Foldable.Foldable Text.Html.Nice.Internal.Attr
instance GHC.Base.Functor Text.Html.Nice.Internal.Attr
instance GHC.Classes.Eq a => GHC.Classes.Eq (Text.Html.Nice.Internal.Attr a)
instance GHC.Show.Show a => GHC.Show.Show (Text.Html.Nice.Internal.Attr a)
instance GHC.Show.Show a => GHC.Show.Show (Text.Html.Nice.Internal.Stream a)
instance GHC.Classes.Eq (Text.Html.Nice.Internal.Stream a)
instance GHC.Base.Functor Text.Html.Nice.Internal.Stream
instance Data.Foldable.Foldable Text.Html.Nice.Internal.Stream
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Text.Html.Nice.Internal.Stream a)
instance GHC.Show.Show a => GHC.Show.Show (a Text.Html.Nice.Internal.:$ b)
instance GHC.Base.Monoid (Text.Html.Nice.Internal.FastMarkup a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Text.Html.Nice.Internal.FastMarkup a)

module Text.Html.Nice.Writer

-- | A Writer-like monad
data Markup p a

-- | Insert text and escape it
text :: Text -> Markup t ()

-- | Insert text and escape it
lazyText :: Text -> Markup n ()

-- | Insert text and escape it
builder :: Builder -> Markup n ()

-- | Insert text and escape it
string :: String -> Markup n ()
doctype_ :: Markup p ()

-- | Insert text and don't escape it
textRaw :: Text -> Markup t ()

-- | Insert text and don't escape it
lazyTextRaw :: Text -> Markup n ()

-- | Insert text and don't escape it
builderRaw :: Builder -> Markup n ()

-- | Insert text and don't escape it
stringRaw :: String -> Markup n ()
class AddAttr a t | a -> t
(!) :: AddAttr a t => MarkupLike a -> Attr t -> MarkupLike a
infixl 8 !
dynamic :: p -> Markup p ()
dynamicRaw :: p -> Markup p ()
using :: ToFastMarkup b => (a -> b) -> Markup (a -> FastMarkup r) ()

-- | Sub-template
sub :: Markup n a -> Markup (FastMarkup n) a

-- | Map over the holes in a <a>Markup</a>. This necessarily discards any
--   attributes currently being added that are not static.
mapP :: (a -> b) -> Markup a r -> Markup b r
stream :: Foldable f => Markup (a -> n) r -> Markup (f a -> FastMarkup n) r
data Note a
Note :: {-# UNPACK #-} !Int -> FastMarkup a -> Note a
[noteId] :: Note a -> {-# UNPACK #-} !Int
[noted] :: Note a -> FastMarkup a

-- | Give a node a unique id
--   
--   Might be handy to build server-side react-esque systems
note :: (Markup t a -> Markup t b) -> Markup t a -> Markup t (Note t, b)

-- | Compile a <a>Markup</a>. Don't run this multiple times!
compile :: Markup t a -> FastMarkup t

-- | Compile a <a>Markup</a>. Don't run this multiple times!
--   
--   Same as <a>compile</a> but lets you use the result.
runMarkup :: Markup t a -> (a, FastMarkup t)
makeElement :: Text -> Markup p a -> Markup p a
makeVoidElement :: Text -> Markup p ()
instance GHC.Base.Functor Text.Html.Nice.Writer.Note
instance GHC.Show.Show a => GHC.Show.Show (Text.Html.Nice.Writer.Note a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Text.Html.Nice.Writer.Note a)
instance Data.Traversable.Traversable (Text.Html.Nice.Writer.MarkupStep p)
instance Data.Foldable.Foldable (Text.Html.Nice.Writer.MarkupStep p)
instance GHC.Base.Functor (Text.Html.Nice.Writer.MarkupStep p)
instance GHC.Base.Functor (Text.Html.Nice.Writer.Markup p)
instance GHC.Base.Applicative (Text.Html.Nice.Writer.Markup p)
instance GHC.Base.Monad (Text.Html.Nice.Writer.Markup p)
instance a ~ () => Data.String.IsString (Text.Html.Nice.Writer.Markup t a)
instance Text.Html.Nice.Writer.AddAttr (Text.Html.Nice.Writer.Markup t a -> Text.Html.Nice.Writer.Markup t b) t
instance Text.Html.Nice.Writer.AddAttr (Text.Html.Nice.Writer.Markup t a) t

module Text.Html.Nice.Writer.Html5
xmlns_ :: AttrName
wrap_ :: AttrName
width_ :: AttrName
value_ :: AttrName
usemap_ :: AttrName
type_ :: AttrName
title__ :: AttrName
target_ :: AttrName
tabindex_ :: AttrName
summary__ :: AttrName
subject_ :: AttrName
style__ :: AttrName
step_ :: AttrName
start_ :: AttrName
srcdoc_ :: AttrName
src_ :: AttrName
spellcheck_ :: AttrName
span__ :: AttrName
sizes_ :: AttrName
size_ :: AttrName
shape_ :: AttrName
selected_ :: AttrName
seamless_ :: AttrName
scoped_ :: AttrName
scope_ :: AttrName
sandbox_ :: AttrName
rowspan_ :: AttrName
rows_ :: AttrName
reversed_ :: AttrName
required_ :: AttrName
rel_ :: AttrName
readonly_ :: AttrName
radiogroup_ :: AttrName
pubdate_ :: AttrName
preload_ :: AttrName
placeholder_ :: AttrName
ping_ :: AttrName
pattern_ :: AttrName
optimum_ :: AttrName
open_ :: AttrName
onwaiting_ :: AttrName
onvolumechange_ :: AttrName
onunload_ :: AttrName
onundo_ :: AttrName
ontimeupdate_ :: AttrName
onsuspend_ :: AttrName
onsubmit_ :: AttrName
onstorage_ :: AttrName
onstalled_ :: AttrName
onselect_ :: AttrName
onseeking_ :: AttrName
onseeked_ :: AttrName
onscroll_ :: AttrName
onresize_ :: AttrName
onredo_ :: AttrName
onreadystatechange_ :: AttrName
onratechange_ :: AttrName
onpropstate_ :: AttrName
onprogress_ :: AttrName
onplaying_ :: AttrName
onplay_ :: AttrName
onpause_ :: AttrName
onpageshow_ :: AttrName
onpagehide_ :: AttrName
ononline_ :: AttrName
onmousewheel_ :: AttrName
onmouseup_ :: AttrName
onmouseover_ :: AttrName
onmouseout_ :: AttrName
onmousemove_ :: AttrName
onmousedown_ :: AttrName
onmessage_ :: AttrName
onloadstart_ :: AttrName
onloadedmetadata_ :: AttrName
onloadeddata_ :: AttrName
onload_ :: AttrName
onkeyup_ :: AttrName
onkeydown_ :: AttrName
oninvalid_ :: AttrName
oninput_ :: AttrName
onhaschange_ :: AttrName
onforminput_ :: AttrName
onformchange_ :: AttrName
onfocus_ :: AttrName
onerror_ :: AttrName
onended_ :: AttrName
onemptied_ :: AttrName
ondurationchange_ :: AttrName
ondrop_ :: AttrName
ondragstart_ :: AttrName
ondragover_ :: AttrName
ondragleave_ :: AttrName
ondragenter_ :: AttrName
ondragend_ :: AttrName
ondrag_ :: AttrName
ondblclick_ :: AttrName
onclick_ :: AttrName
oncontextmenu_ :: AttrName
onchange_ :: AttrName
oncanplaythrough_ :: AttrName
oncanplay_ :: AttrName
onblur_ :: AttrName
onbeforeprint_ :: AttrName
onbeforeonload_ :: AttrName
novalidate_ :: AttrName
name_ :: AttrName
multiple_ :: AttrName
min_ :: AttrName
method_ :: AttrName
media_ :: AttrName
maxlength_ :: AttrName
max_ :: AttrName
manifest_ :: AttrName
low_ :: AttrName
loop_ :: AttrName
list_ :: AttrName
lang_ :: AttrName
label__ :: AttrName
keytype_ :: AttrName
itemtype_ :: AttrName
itemscope_ :: AttrName
itemprop_ :: AttrName
item_ :: AttrName
ismap_ :: AttrName
id_ :: AttrName
icon_ :: AttrName
http_equiv_ :: AttrName
hreflang_ :: AttrName
href_ :: AttrName
high_ :: AttrName
hidden_ :: AttrName
height_ :: AttrName
headers_ :: AttrName
formtarget_ :: AttrName
formnovalidate_ :: AttrName
formmethod_ :: AttrName
formenctype_ :: AttrName
formaction_ :: AttrName
form__ :: AttrName
for_ :: AttrName
enctype_ :: AttrName
draggable_ :: AttrName
disabled_ :: AttrName
dir_ :: AttrName
defer_ :: AttrName
datetime_ :: AttrName
data_ :: AttrName
coords_ :: AttrName
controls_ :: AttrName
contextmenu_ :: AttrName
contenteditable_ :: AttrName
content_ :: AttrName
colspan_ :: AttrName
cols_ :: AttrName
class_ :: AttrName
cite__ :: AttrName
checked_ :: AttrName
charset_ :: AttrName
challenge_ :: AttrName
autoplay_ :: AttrName
autofocus_ :: AttrName
autocomplete_ :: AttrName
async_ :: AttrName
alt_ :: AttrName
action_ :: AttrName
accesskey_ :: AttrName
accept_charset_ :: AttrName
accept_ :: AttrName
wbr_ :: forall t_aBuW. Markup t_aBuW ()
track_ :: forall t_aBuU. Markup t_aBuU ()
source_ :: forall t_aBuS. Markup t_aBuS ()
param_ :: forall t_aBuQ. Markup t_aBuQ ()
meta_ :: forall t_aBuO. Markup t_aBuO ()
menuitem_ :: forall t_aBuM. Markup t_aBuM ()
link_ :: forall t_aBuK. Markup t_aBuK ()
keygen_ :: forall t_aBuI. Markup t_aBuI ()
input_ :: forall t_aBuG. Markup t_aBuG ()
img_ :: forall t_aBuE. Markup t_aBuE ()
hr_ :: forall t_aBuC. Markup t_aBuC ()
embed_ :: forall t_aBuA. Markup t_aBuA ()
col_ :: forall t_aBuy. Markup t_aBuy ()
br_ :: forall t_aBuw. Markup t_aBuw ()
base_ :: forall t_aBuu. Markup t_aBuu ()
area_ :: forall t_aBus. Markup t_aBus ()
video_ :: forall t_aBup a_aBuq. Markup t_aBup a_aBuq -> Markup t_aBup a_aBuq
var_ :: forall t_aBum a_aBun. Markup t_aBum a_aBun -> Markup t_aBum a_aBun
ul_ :: forall t_aBuj a_aBuk. Markup t_aBuj a_aBuk -> Markup t_aBuj a_aBuk
tr_ :: forall t_aBug a_aBuh. Markup t_aBug a_aBuh -> Markup t_aBug a_aBuh
title_ :: forall t_aBud a_aBue. Markup t_aBud a_aBue -> Markup t_aBud a_aBue
time_ :: forall t_aBua a_aBub. Markup t_aBua a_aBub -> Markup t_aBua a_aBub
thead_ :: forall t_aBu7 a_aBu8. Markup t_aBu7 a_aBu8 -> Markup t_aBu7 a_aBu8
th_ :: forall t_aBu4 a_aBu5. Markup t_aBu4 a_aBu5 -> Markup t_aBu4 a_aBu5
tfoot_ :: forall t_aBu1 a_aBu2. Markup t_aBu1 a_aBu2 -> Markup t_aBu1 a_aBu2
textarea_ :: forall t_aBtY a_aBtZ. Markup t_aBtY a_aBtZ -> Markup t_aBtY a_aBtZ
td_ :: forall t_aBtV a_aBtW. Markup t_aBtV a_aBtW -> Markup t_aBtV a_aBtW
tbody_ :: forall t_aBtS a_aBtT. Markup t_aBtS a_aBtT -> Markup t_aBtS a_aBtT
table_ :: forall t_aBtP a_aBtQ. Markup t_aBtP a_aBtQ -> Markup t_aBtP a_aBtQ
sup_ :: forall t_aBtM a_aBtN. Markup t_aBtM a_aBtN -> Markup t_aBtM a_aBtN
summary_ :: forall t_aBtJ a_aBtK. Markup t_aBtJ a_aBtK -> Markup t_aBtJ a_aBtK
sub_ :: forall t_aBtG a_aBtH. Markup t_aBtG a_aBtH -> Markup t_aBtG a_aBtH
style_ :: forall t_aBtD a_aBtE. Markup t_aBtD a_aBtE -> Markup t_aBtD a_aBtE
strong_ :: forall t_aBtA a_aBtB. Markup t_aBtA a_aBtB -> Markup t_aBtA a_aBtB
span_ :: forall t_aBtx a_aBty. Markup t_aBtx a_aBty -> Markup t_aBtx a_aBty
small_ :: forall t_aBtu a_aBtv. Markup t_aBtu a_aBtv -> Markup t_aBtu a_aBtv
select_ :: forall t_aBtr a_aBts. Markup t_aBtr a_aBts -> Markup t_aBtr a_aBts
section_ :: forall t_aBto a_aBtp. Markup t_aBto a_aBtp -> Markup t_aBto a_aBtp
script_ :: forall t_aBtl a_aBtm. Markup t_aBtl a_aBtm -> Markup t_aBtl a_aBtm
samp_ :: forall t_aBti a_aBtj. Markup t_aBti a_aBtj -> Markup t_aBti a_aBtj
ruby_ :: forall t_aBtf a_aBtg. Markup t_aBtf a_aBtg -> Markup t_aBtf a_aBtg
rt_ :: forall t_aBtc a_aBtd. Markup t_aBtc a_aBtd -> Markup t_aBtc a_aBtd
rp_ :: forall t_aBt9 a_aBta. Markup t_aBt9 a_aBta -> Markup t_aBt9 a_aBta
q_ :: forall t_aBt6 a_aBt7. Markup t_aBt6 a_aBt7 -> Markup t_aBt6 a_aBt7
progress_ :: forall t_aBt3 a_aBt4. Markup t_aBt3 a_aBt4 -> Markup t_aBt3 a_aBt4
pre_ :: forall t_aBt0 a_aBt1. Markup t_aBt0 a_aBt1 -> Markup t_aBt0 a_aBt1
p_ :: forall t_aBsX a_aBsY. Markup t_aBsX a_aBsY -> Markup t_aBsX a_aBsY
output_ :: forall t_aBsU a_aBsV. Markup t_aBsU a_aBsV -> Markup t_aBsU a_aBsV
option_ :: forall t_aBsR a_aBsS. Markup t_aBsR a_aBsS -> Markup t_aBsR a_aBsS
optgroup_ :: forall t_aBsO a_aBsP. Markup t_aBsO a_aBsP -> Markup t_aBsO a_aBsP
ol_ :: forall t_aBsL a_aBsM. Markup t_aBsL a_aBsM -> Markup t_aBsL a_aBsM
object_ :: forall t_aBsI a_aBsJ. Markup t_aBsI a_aBsJ -> Markup t_aBsI a_aBsJ
noscript_ :: forall t_aBsF a_aBsG. Markup t_aBsF a_aBsG -> Markup t_aBsF a_aBsG
nav_ :: forall t_aBsC a_aBsD. Markup t_aBsC a_aBsD -> Markup t_aBsC a_aBsD
meter_ :: forall t_aBsz a_aBsA. Markup t_aBsz a_aBsA -> Markup t_aBsz a_aBsA
menu_ :: forall t_aBsw a_aBsx. Markup t_aBsw a_aBsx -> Markup t_aBsw a_aBsx
mark_ :: forall t_aBst a_aBsu. Markup t_aBst a_aBsu -> Markup t_aBst a_aBsu
map_ :: forall t_aBsq a_aBsr. Markup t_aBsq a_aBsr -> Markup t_aBsq a_aBsr
main_ :: forall t_aBsn a_aBso. Markup t_aBsn a_aBso -> Markup t_aBsn a_aBso
li_ :: forall t_aBsk a_aBsl. Markup t_aBsk a_aBsl -> Markup t_aBsk a_aBsl
legend_ :: forall t_aBsh a_aBsi. Markup t_aBsh a_aBsi -> Markup t_aBsh a_aBsi
label_ :: forall t_aBse a_aBsf. Markup t_aBse a_aBsf -> Markup t_aBse a_aBsf
kbd_ :: forall t_aBsb a_aBsc. Markup t_aBsb a_aBsc -> Markup t_aBsb a_aBsc
ins_ :: forall t_aBs8 a_aBs9. Markup t_aBs8 a_aBs9 -> Markup t_aBs8 a_aBs9
iframe_ :: forall t_aBs5 a_aBs6. Markup t_aBs5 a_aBs6 -> Markup t_aBs5 a_aBs6
i_ :: forall t_aBs2 a_aBs3. Markup t_aBs2 a_aBs3 -> Markup t_aBs2 a_aBs3
html_ :: forall t_aBrZ a_aBs0. Markup t_aBrZ a_aBs0 -> Markup t_aBrZ a_aBs0
hgroup_ :: forall t_aBrW a_aBrX. Markup t_aBrW a_aBrX -> Markup t_aBrW a_aBrX
header_ :: forall t_aBrT a_aBrU. Markup t_aBrT a_aBrU -> Markup t_aBrT a_aBrU
head_ :: forall t_aBrQ a_aBrR. Markup t_aBrQ a_aBrR -> Markup t_aBrQ a_aBrR
h6_ :: forall t_aBrN a_aBrO. Markup t_aBrN a_aBrO -> Markup t_aBrN a_aBrO
h5_ :: forall t_aBrK a_aBrL. Markup t_aBrK a_aBrL -> Markup t_aBrK a_aBrL
h4_ :: forall t_aBrH a_aBrI. Markup t_aBrH a_aBrI -> Markup t_aBrH a_aBrI
h3_ :: forall t_aBrE a_aBrF. Markup t_aBrE a_aBrF -> Markup t_aBrE a_aBrF
h2_ :: forall t_aBrB a_aBrC. Markup t_aBrB a_aBrC -> Markup t_aBrB a_aBrC
h1_ :: forall t_aBry a_aBrz. Markup t_aBry a_aBrz -> Markup t_aBry a_aBrz
form_ :: forall t_aBrv a_aBrw. Markup t_aBrv a_aBrw -> Markup t_aBrv a_aBrw
footer_ :: forall t_aBrs a_aBrt. Markup t_aBrs a_aBrt -> Markup t_aBrs a_aBrt
figure_ :: forall t_aBrp a_aBrq. Markup t_aBrp a_aBrq -> Markup t_aBrp a_aBrq
figcaption_ :: forall t_aBrm a_aBrn. Markup t_aBrm a_aBrn -> Markup t_aBrm a_aBrn
fieldset_ :: forall t_aBrj a_aBrk. Markup t_aBrj a_aBrk -> Markup t_aBrj a_aBrk
em_ :: forall t_aBrg a_aBrh. Markup t_aBrg a_aBrh -> Markup t_aBrg a_aBrh
dt_ :: forall t_aBrd a_aBre. Markup t_aBrd a_aBre -> Markup t_aBrd a_aBre
dl_ :: forall t_aBra a_aBrb. Markup t_aBra a_aBrb -> Markup t_aBra a_aBrb
div_ :: forall t_aBr7 a_aBr8. Markup t_aBr7 a_aBr8 -> Markup t_aBr7 a_aBr8
dfn_ :: forall t_aBr4 a_aBr5. Markup t_aBr4 a_aBr5 -> Markup t_aBr4 a_aBr5
details_ :: forall t_aBr1 a_aBr2. Markup t_aBr1 a_aBr2 -> Markup t_aBr1 a_aBr2
del_ :: forall t_aBqY a_aBqZ. Markup t_aBqY a_aBqZ -> Markup t_aBqY a_aBqZ
dd_ :: forall t_aBqV a_aBqW. Markup t_aBqV a_aBqW -> Markup t_aBqV a_aBqW
datalist_ :: forall t_aBqS a_aBqT. Markup t_aBqS a_aBqT -> Markup t_aBqS a_aBqT
command_ :: forall t_aBqP a_aBqQ. Markup t_aBqP a_aBqQ -> Markup t_aBqP a_aBqQ
colgroup_ :: forall t_aBqM a_aBqN. Markup t_aBqM a_aBqN -> Markup t_aBqM a_aBqN
code_ :: forall t_aBqJ a_aBqK. Markup t_aBqJ a_aBqK -> Markup t_aBqJ a_aBqK
cite_ :: forall t_aBqG a_aBqH. Markup t_aBqG a_aBqH -> Markup t_aBqG a_aBqH
caption_ :: forall t_aBqD a_aBqE. Markup t_aBqD a_aBqE -> Markup t_aBqD a_aBqE
canvas_ :: forall t_aBqA a_aBqB. Markup t_aBqA a_aBqB -> Markup t_aBqA a_aBqB
button_ :: forall t_aBqx a_aBqy. Markup t_aBqx a_aBqy -> Markup t_aBqx a_aBqy
body_ :: forall t_aBqu a_aBqv. Markup t_aBqu a_aBqv -> Markup t_aBqu a_aBqv
blockquote_ :: forall t_aBqr a_aBqs. Markup t_aBqr a_aBqs -> Markup t_aBqr a_aBqs
bdo_ :: forall t_aBqo a_aBqp. Markup t_aBqo a_aBqp -> Markup t_aBqo a_aBqp
b_ :: forall t_aBql a_aBqm. Markup t_aBql a_aBqm -> Markup t_aBql a_aBqm
audio_ :: forall t_aBqi a_aBqj. Markup t_aBqi a_aBqj -> Markup t_aBqi a_aBqj
aside_ :: forall t_aBqf a_aBqg. Markup t_aBqf a_aBqg -> Markup t_aBqf a_aBqg
article_ :: forall t_aBqc a_aBqd. Markup t_aBqc a_aBqd -> Markup t_aBqc a_aBqd
address_ :: forall t_aBq9 a_aBqa. Markup t_aBq9 a_aBqa -> Markup t_aBq9 a_aBqa
abbr_ :: forall t_aBq6 a_aBq7. Markup t_aBq6 a_aBq7 -> Markup t_aBq6 a_aBq7
a_ :: forall t_aBq3 a_aBq4. Markup t_aBq3 a_aBq4 -> Markup t_aBq3 a_aBq4


-- | A <tt>Free</tt> monad-based HTML markup monad. Unlike the writer-like
--   monad in <a>Text.Html.Nice.Writer</a>, sequencing bits of markup
--   together results in them being nested, rather than concatenated.
--   
--   There is no kitchen-sink of HTML5 elements provided. Use
--   OverloadedLabels instead: <tt> #div :: Markup n () </tt> and <tt> #div
--   :: MakeNode n () </tt>.
--   
--   Since the monad and applicative of <a>Markup</a> here nests rather
--   than concatenates, the function <a>nodes</a> is provided to put a list
--   of nodes in sequence. You can use OverloadedLists for convenient
--   syntax here.
--   
--   Example Markup:
--   
--   <pre>
--   #html &gt;&gt;
--   [ title &gt;&gt; "Title goes here"
--   , #body &gt;&gt;
--     [ #h1 &gt;&gt; "heading goes here"
--     , #p &gt;&gt; "i am a paragraph below the heading"
--     , do i &lt;- branch [0..100]
--          builder (decimal i)
--     ]
--   ]
--   </pre>
module Text.Html.Nice.FreeMonad

-- | <a>Markup</a> is a free monad based on the base functor to 'Markup\'F'
--   
--   Beware: this is a wacky monad. <a>&gt;&gt;</a> does *not* sequence
--   nodes together; instead, it nests them. To lay out nodes sequentially,
--   use <a>nodes</a>.
--   
--   <h1>Syntactic sugar</h1>
--   
--   <a>Markup</a> supports <tt>OverloadedLabels</tt>,
--   <tt>OverloadedStrings</tt> and <tt>OverloadedLists</tt>.
--   
--   <h2><tt>OverloadedStrings</tt></h2>
--   
--   <pre>
--   ("foo" :: Markup n a) = <a>text</a> "foo"
--   </pre>
--   
--   <h2><tt>OverloadedLists</tt></h2>
--   
--   <pre>
--   ([a,b,c] :: Markup n a) = <a>nodes</a> [a,b,c]
--   </pre>
--   
--   <h2><tt>OverloadedLabels</tt></h2>
--   
--   The <a>IsLabel</a> instances give a convenient way to write nodes.
--   
--   <h3>Nodes without attributes</h3>
--   
--   <pre>
--   (#foo :: <a>Markup</a> n a) = <a>node</a> "foo" []
--   </pre>
--   
--   <h3>Nodes with attributes</h3>
--   
--   <pre>
--   <a>attr</a> #foo [a,b,c] = <a>node</a> "foo" [a,b,c]
--   </pre>
data Markup n a
data FastMarkup a
runMarkup :: Markup n a -> Markup' n

-- | Compile a <tt>Html</tt> for use with <a>render</a> and its friends.
--   
--   See also: <a>compile_</a>.
compile :: Markup n a -> FastMarkup n

-- | Render <a>FastMarkup</a>
renderM :: Monad m => (a -> m Builder) -> FastMarkup a -> m Builder

-- | Render <a>FastMarkup</a> by recursively rendering any sub-markup.
renderMs :: Monad m => (a -> m (FastMarkup Void)) -> FastMarkup a -> m Builder

-- | Render <a>FastMarkup</a> that has no holes.
render :: FastMarkup Void -> Builder

-- | Identity functor and monad. (a non-strict monad)
newtype Identity a :: * -> *
Identity :: a -> Identity a
[runIdentity] :: Identity a -> a

-- | <i>O(n).</i> Extract a lazy <tt>Text</tt> from a <tt>Builder</tt> with
--   a default buffer size. The construction work takes place if and when
--   the relevant part of the lazy <tt>Text</tt> is demanded.
toLazyText :: Builder -> Text
doctype :: Markup n a

-- | Make a node with some attributes.
node :: Text -> [Attr n] -> Markup n ()
data Attr a
(:=) :: !AttrName -> !Text -> Attr a
[attrKey] :: Attr a -> !AttrName
[attrVal] :: Attr a -> !Text
(:-) :: !AttrName -> a -> Attr a
[attrKey] :: Attr a -> !AttrName
[attrValHole] :: Attr a -> a

-- | For use with <tt>OverloadedLabels</tt>.
--   
--   <pre>
--   <a>attr</a> #x [a,b,c] = <a>node</a> "x" [a,b,c]
--   </pre>
attr :: MakeNode n a -> [Attr n] -> Markup n a

-- | Empty node. Terminates <a>Markup</a> to this point
empty :: Markup n a

-- | Insert text and escape it
text :: Text -> Markup n a

-- | Insert text and escape it
lazyText :: Text -> Markup n a

-- | Insert text and escape it
builder :: Builder -> Markup n a

-- | Insert text and don't escape it
unescape :: Text -> Markup n a

-- | Insert text and escape it
string :: String -> Markup n a

-- | Insert a dynamic value.
dynamic :: n -> Markup n a
hole :: Markup (a -> a) t

-- | Insert a sub-template.
embed :: (t -> FastMarkup n) -> Markup (t -> FastMarkup n) a

-- | For each element of a list, generate sequential markup
nodes :: [Markup n a] -> Markup n a

-- | For each element of a list of branches, generate sequential markup
branch :: [a] -> Markup n a
stream :: Foldable f => Markup (a -> n) r' -> Markup (f a -> FastMarkup n) r

-- | Insert a sub-template.
sub :: Markup n a -> Markup (FastMarkup n) a
decimal :: Integral a => a -> Builder

-- | Show a signed <a>RealFloat</a> value to full precision, using standard
--   decimal notation for arguments whose absolute value lies between
--   <tt>0.1</tt> and <tt>9,999,999</tt>, and scientific notation
--   otherwise.
realFloat :: RealFloat a => a -> Builder

-- | <i>O(1).</i> A <tt>Builder</tt> taking a <a>Text</a>, satisfying
--   
--   <ul>
--   <li><pre><a>toLazyText</a> (<a>fromText</a> t) = <a>fromChunks</a>
--   [t]</pre></li>
--   </ul>
fromText :: Text -> Builder

-- | <i>O(1).</i> A Builder taking a <tt>String</tt>, satisfying
--   
--   <ul>
--   <li><pre><a>toLazyText</a> (<a>fromString</a> s) = <a>fromChunks</a>
--   [S.pack s]</pre></li>
--   </ul>
fromString :: String -> Builder

-- | <i>O(1).</i> A <tt>Builder</tt> taking a lazy <tt>Text</tt>,
--   satisfying
--   
--   <ul>
--   <li><pre><a>toLazyText</a> (<a>fromLazyText</a> t) = t</pre></li>
--   </ul>
fromLazyText :: Text -> Builder

-- | A <tt>Builder</tt> is an efficient way to build lazy <tt>Text</tt>
--   values. There are several functions for constructing builders, but
--   only one to inspect them: to extract any data, you have to turn them
--   into lazy <tt>Text</tt> values using <tt>toLazyText</tt>.
--   
--   Internally, a builder constructs a lazy <tt>Text</tt> by filling
--   arrays piece by piece. As each buffer is filled, it is 'popped' off,
--   to become a new chunk of the resulting lazy <tt>Text</tt>. All this is
--   hidden from the user of the <tt>Builder</tt>.
data Builder :: *

-- | Uninhabited data type
data Void :: *
instance Control.Monad.Free.Class.MonadFree (Text.Html.Nice.Internal.Markup'F n) (Text.Html.Nice.FreeMonad.Markup n)
instance GHC.Base.Monad (Text.Html.Nice.FreeMonad.Markup n)
instance GHC.Base.Applicative (Text.Html.Nice.FreeMonad.Markup n)
instance GHC.Base.Functor (Text.Html.Nice.FreeMonad.Markup n)
instance Data.Default.Class.Default (Text.Html.Nice.FreeMonad.Markup n a)
instance GHC.Base.Monoid (Text.Html.Nice.FreeMonad.Markup n a)
instance Data.String.IsString (Text.Html.Nice.FreeMonad.Markup n a)
instance GHC.Exts.IsList (Text.Html.Nice.FreeMonad.Markup n a)
instance (a ~ (), GHC.TypeLits.KnownSymbol s) => GHC.OverloadedLabels.IsLabel s (Text.Html.Nice.FreeMonad.Markup n a)
instance (a ~ (), GHC.TypeLits.KnownSymbol s) => GHC.OverloadedLabels.IsLabel s (Text.Html.Nice.FreeMonad.MakeNode n a)
instance Data.Bifunctor.Bifunctor Text.Html.Nice.FreeMonad.Markup

module Text.Html.Nice
data Attr a
(:=) :: !AttrName -> !Text -> Attr a
[attrKey] :: Attr a -> !AttrName
[attrVal] :: Attr a -> !Text
(:-) :: !AttrName -> a -> Attr a
[attrKey] :: Attr a -> !AttrName
[attrValHole] :: Attr a -> a
data FastMarkup a
class Render a m
r :: Render a m => a -> m Builder
data (:$) a b
(:$) :: (FastMarkup (a -> b)) -> a -> (:$) a b

-- | Render <a>FastMarkup</a>
renderM :: Monad m => (a -> m Builder) -> FastMarkup a -> m Builder

-- | Render <a>FastMarkup</a> by recursively rendering any sub-markup.
renderMs :: Monad m => (a -> m (FastMarkup Void)) -> FastMarkup a -> m Builder

-- | Render <a>FastMarkup</a> that has no holes.
render :: FastMarkup Void -> Builder
recompile :: FastMarkup a -> FastMarkup a
unlayer :: FastMarkup (FastMarkup a) -> FastMarkup a
data Text :: *

-- | <i>O(c)</i> Convert a strict <a>Text</a> into a lazy <a>Text</a>.
fromStrict :: Text -> Text

-- | <i>O(n)</i> Convert a lazy <a>Text</a> into a strict <a>Text</a>.
toStrict :: Text -> Text