Is there a less awkward way to use blaze-html with a Reader monad?

Question

The BlazeHtml tutorial suggests using a Reader monad for real-world templating with BlazeHtml, but without illustrating how this should be done. I tried following this recommendation. The result leaves me confused.

To illustrate, assume I have a simple User type, and I want to compose my HTML using separate functions, one for the layout, and another for a part of the HTML page where I display user information. If I use a Reader Monad, it looks like this:

data User = User {
    username :: Text
  , userId :: nt
  } deriving (Show)

userBox :: Reader User Html
userBox = do
  user <- ask
  return $ do
      dl $ do
        dt $ "Username"
        dd $ H.toHtml $ username user
        dt $ "UserId"
        dd $ H.toHtml $ userId user

page :: Reader User Html
page = do
  user <- ask
  return $ H.docTypeHtml $ do
    H.head $ title "Reader Monad Blaze Example"
    H.body $ do
      h1 $ "Hello world"
      runReader userBox user

Compare this to my version that doesn't use the Reader monad:

userBox :: User -> Html
userBox user = do
      dl $ do
        dt $ "Username"
        dd $ H.toHtml $ username user
        dt $ "UserId"
        dd $ H.toHtml $ userId user

page :: User -> Html
page user = do
  H.docTypeHtml $ do
    H.head $ title "Blaze Example, No Reader Monad"
    H.body $ do
      h1 $ "Hello world"
      userBox user

So I'm having trouble seeing how a Reader Monad can actually tighten up the templating code in real-world use cases. Am I missing something?

J. Abrahamson · Accepted Answer · 2013-12-23T21:42:46.983

7

If you expand your types you'll see that

page :: Reader User Html
     :: Reader User Markup
     :: Reader User (MarkupM ())

So you might get more leverage by using a transformer stack.

l :: (Html -> Html) -> ReaderT r MarkupM () -> ReaderT r MarkupM ()
l = mapReaderT

r :: Html -> ReaderT r MarkupM ()
r = lift

asksHtml :: ToMarkup a => (r -> a) -> ReaderT r MarkupM ()
asksHtml f = ReaderT (asks (H.toHtml . f))

userBox :: ReaderT User MarkupM ()
userBox = do
      l dl $ do
        r $ dt "Username"
        l dd (asksHtml username)
        r $ dt "UserId"
        l dd (asksHtml userId)

page :: ReaderT User MarkupM ()
page = do
  l H.docTypeHtml $ do
    r $ H.head $ title "Reader Monad Blaze Example"
    l H.body $ do
      r $ h1 "Hello world"
      userBox

edited Dec 23 '13 at 21:42

answered Dec 23 '13 at 20:42

J. Abrahamson

72,246
9
135
180

Thanks. But am I wrong in wondering why the resulting code doesn't seem to be very elegant? Having to prefix every line with `l` or `r` doesn't seem to be more concise than threading a User argument through nested functions. – dan Dec 23 '13 at 21:22
Note that not every line requires the annotation. `l` is used when introducing a new block under some `(Html -> Html)`-typed operator and `r` is used when lifting an `Html`-typed value up into the `ReaderT`. Lines like `userBox` at the bottom require no annotation. Further, you only need `l` and `r` annotating every line when they alternate, you can get away with fewer of them if there are large sections of static template. You could use a typeclass perhaps to lift the `Text.Blaze.Html5` operators up into the `ReaderT` monad stack naturally, but I think a little operator adornment is nicer. – J. Abrahamson Dec 23 '13 at 21:44
I suppose the short answer is that I'm not sure how you might eventually find the optimally elegant expression of this template, but a transformer stack is a good tool for doing it. *Especially* if you start to need more complex effects inside of your `Html`. – J. Abrahamson Dec 23 '13 at 21:45
Thanks for the explanations. They're helpful. – dan Dec 23 '13 at 21:49
MarkupM is currently (0.6.0.0) only exported from Text.Blaze.Internal. I assume, then, that it is unsafe to depend on MarkupM at all, even in 0.6.* releases. Is this the case? – Savanni D'Gerinel Apr 06 '14 at 17:19

score 0 · Answer 2 · answered Aug 28 '18 at 13:34

Blaze's Markup type is not a transformer, so it can't be used to transform a ReaderT.

type Markup = MarkupM ()
data MarkupM a

You can use the lucid package (tutorial here), like this:

$ stack build lucid
$ stack exec ghci
GHCi, version 8.2.2: http://www.haskell.org/ghc/  :? for help
> :set -XOverloadedStrings -XExtendedDefaultRules
> import Lucid
> import Control.Monad.Trans.Reader
> import Control.Monad.Trans
> runReaderT (renderTextT (do p_ (do title <- lift ask; strong_ (toHtml title)))) "Hi"
"<p><strong>Hi</strong></p>"
>

Is there a less awkward way to use blaze-html with a Reader monad?

2 Answers2