{-# LANGUAGE FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, TypeFamilies, TypeSynonymInstances, QuasiQuotes, OverloadedStrings #-}
-- | This experimental module provides a monad transformer 'JMacroT'
-- and corresponding 'XMLGenerator' instance which can be used to
-- directly generate javascript which builds an XML/HTML DOM.
--
-- This is similar to the 'ToJExpr XMLToDOM' instance except that
-- there is no intermediate XML type. The 'XMLGenerator' instance
-- directly generates the javascript needed to build the DOM.
--
-- This is intellectually fun. But it is not clear how it is valuable.
-- That is why this module is marked as experimental.
module HSP.JMacroT
    ( JMacroT(..)
    , evalJMacroT
    , mapJMacroT
    , JMacroM
    , evalJMacroM
    ) where

import Control.Applicative        (Applicative, Alternative)
import Control.Monad              (MonadPlus)
import Control.Monad.Cont         (MonadCont)
import Control.Monad.Identity     (Identity(..))
import Control.Monad.Error        (MonadError)
import Control.Monad.Reader       (MonadReader)
import Control.Monad.State        (MonadState)
import Control.Monad.Writer       (MonadWriter)
import Control.Monad.RWS          (MonadRWS)
import Control.Monad.Trans        (MonadIO, MonadTrans(..))
import qualified Data.Text        as Strict
import qualified Data.Text.Lazy   as Lazy
import HSP.XMLGenerator           (Attr(..), XMLGen(..), XMLGenT(..), XMLGenerator, AppendChild(..), EmbedAsAttr(..), EmbedAsChild(..), Name(..), SetAttr(..), unXMLGenT)

import Language.Javascript.JMacro (ToJExpr(..), JExpr(..), JStat(..), JVal(JVar), Ident(StrI), ToStat(..), jmacroE, jLam, jVarTy)

-- | isomorphic to IdentityT, but used for generating javascript that generates XML/HTML
newtype JMacroT m a = JMacroT { JMacroT m a -> m a
unJMacroT :: m a }
    deriving ( a -> JMacroT m b -> JMacroT m a
(a -> b) -> JMacroT m a -> JMacroT m b
(forall a b. (a -> b) -> JMacroT m a -> JMacroT m b)
-> (forall a b. a -> JMacroT m b -> JMacroT m a)
-> Functor (JMacroT m)
forall a b. a -> JMacroT m b -> JMacroT m a
forall a b. (a -> b) -> JMacroT m a -> JMacroT m b
forall (m :: * -> *) a b.
Functor m =>
a -> JMacroT m b -> JMacroT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> JMacroT m a -> JMacroT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> JMacroT m b -> JMacroT m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> JMacroT m b -> JMacroT m a
fmap :: (a -> b) -> JMacroT m a -> JMacroT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> JMacroT m a -> JMacroT m b
Functor, Functor (JMacroT m)
a -> JMacroT m a
Functor (JMacroT m)
-> (forall a. a -> JMacroT m a)
-> (forall a b. JMacroT m (a -> b) -> JMacroT m a -> JMacroT m b)
-> (forall a b c.
    (a -> b -> c) -> JMacroT m a -> JMacroT m b -> JMacroT m c)
-> (forall a b. JMacroT m a -> JMacroT m b -> JMacroT m b)
-> (forall a b. JMacroT m a -> JMacroT m b -> JMacroT m a)
-> Applicative (JMacroT m)
JMacroT m a -> JMacroT m b -> JMacroT m b
JMacroT m a -> JMacroT m b -> JMacroT m a
JMacroT m (a -> b) -> JMacroT m a -> JMacroT m b
(a -> b -> c) -> JMacroT m a -> JMacroT m b -> JMacroT m c
forall a. a -> JMacroT m a
forall a b. JMacroT m a -> JMacroT m b -> JMacroT m a
forall a b. JMacroT m a -> JMacroT m b -> JMacroT m b
forall a b. JMacroT m (a -> b) -> JMacroT m a -> JMacroT m b
forall a b c.
(a -> b -> c) -> JMacroT m a -> JMacroT m b -> JMacroT m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (m :: * -> *). Applicative m => Functor (JMacroT m)
forall (m :: * -> *) a. Applicative m => a -> JMacroT m a
forall (m :: * -> *) a b.
Applicative m =>
JMacroT m a -> JMacroT m b -> JMacroT m a
forall (m :: * -> *) a b.
Applicative m =>
JMacroT m a -> JMacroT m b -> JMacroT m b
forall (m :: * -> *) a b.
Applicative m =>
JMacroT m (a -> b) -> JMacroT m a -> JMacroT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> JMacroT m a -> JMacroT m b -> JMacroT m c
<* :: JMacroT m a -> JMacroT m b -> JMacroT m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
JMacroT m a -> JMacroT m b -> JMacroT m a
*> :: JMacroT m a -> JMacroT m b -> JMacroT m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
JMacroT m a -> JMacroT m b -> JMacroT m b
liftA2 :: (a -> b -> c) -> JMacroT m a -> JMacroT m b -> JMacroT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> JMacroT m a -> JMacroT m b -> JMacroT m c
<*> :: JMacroT m (a -> b) -> JMacroT m a -> JMacroT m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
JMacroT m (a -> b) -> JMacroT m a -> JMacroT m b
pure :: a -> JMacroT m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> JMacroT m a
$cp1Applicative :: forall (m :: * -> *). Applicative m => Functor (JMacroT m)
Applicative, Applicative (JMacroT m)
JMacroT m a
Applicative (JMacroT m)
-> (forall a. JMacroT m a)
-> (forall a. JMacroT m a -> JMacroT m a -> JMacroT m a)
-> (forall a. JMacroT m a -> JMacroT m [a])
-> (forall a. JMacroT m a -> JMacroT m [a])
-> Alternative (JMacroT m)
JMacroT m a -> JMacroT m a -> JMacroT m a
JMacroT m a -> JMacroT m [a]
JMacroT m a -> JMacroT m [a]
forall a. JMacroT m a
forall a. JMacroT m a -> JMacroT m [a]
forall a. JMacroT m a -> JMacroT m a -> JMacroT m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (m :: * -> *). Alternative m => Applicative (JMacroT m)
forall (m :: * -> *) a. Alternative m => JMacroT m a
forall (m :: * -> *) a.
Alternative m =>
JMacroT m a -> JMacroT m [a]
forall (m :: * -> *) a.
Alternative m =>
JMacroT m a -> JMacroT m a -> JMacroT m a
many :: JMacroT m a -> JMacroT m [a]
$cmany :: forall (m :: * -> *) a.
Alternative m =>
JMacroT m a -> JMacroT m [a]
some :: JMacroT m a -> JMacroT m [a]
$csome :: forall (m :: * -> *) a.
Alternative m =>
JMacroT m a -> JMacroT m [a]
<|> :: JMacroT m a -> JMacroT m a -> JMacroT m a
$c<|> :: forall (m :: * -> *) a.
Alternative m =>
JMacroT m a -> JMacroT m a -> JMacroT m a
empty :: JMacroT m a
$cempty :: forall (m :: * -> *) a. Alternative m => JMacroT m a
$cp1Alternative :: forall (m :: * -> *). Alternative m => Applicative (JMacroT m)
Alternative, Applicative (JMacroT m)
a -> JMacroT m a
Applicative (JMacroT m)
-> (forall a b. JMacroT m a -> (a -> JMacroT m b) -> JMacroT m b)
-> (forall a b. JMacroT m a -> JMacroT m b -> JMacroT m b)
-> (forall a. a -> JMacroT m a)
-> Monad (JMacroT m)
JMacroT m a -> (a -> JMacroT m b) -> JMacroT m b
JMacroT m a -> JMacroT m b -> JMacroT m b
forall a. a -> JMacroT m a
forall a b. JMacroT m a -> JMacroT m b -> JMacroT m b
forall a b. JMacroT m a -> (a -> JMacroT m b) -> JMacroT m b
forall (m :: * -> *). Monad m => Applicative (JMacroT m)
forall (m :: * -> *) a. Monad m => a -> JMacroT m a
forall (m :: * -> *) a b.
Monad m =>
JMacroT m a -> JMacroT m b -> JMacroT m b
forall (m :: * -> *) a b.
Monad m =>
JMacroT m a -> (a -> JMacroT m b) -> JMacroT m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> JMacroT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> JMacroT m a
>> :: JMacroT m a -> JMacroT m b -> JMacroT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
JMacroT m a -> JMacroT m b -> JMacroT m b
>>= :: JMacroT m a -> (a -> JMacroT m b) -> JMacroT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
JMacroT m a -> (a -> JMacroT m b) -> JMacroT m b
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (JMacroT m)
Monad, Monad (JMacroT m)
Monad (JMacroT m)
-> (forall a. IO a -> JMacroT m a) -> MonadIO (JMacroT m)
IO a -> JMacroT m a
forall a. IO a -> JMacroT m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *). MonadIO m => Monad (JMacroT m)
forall (m :: * -> *) a. MonadIO m => IO a -> JMacroT m a
liftIO :: IO a -> JMacroT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> JMacroT m a
$cp1MonadIO :: forall (m :: * -> *). MonadIO m => Monad (JMacroT m)
MonadIO, Monad (JMacroT m)
Alternative (JMacroT m)
JMacroT m a
Alternative (JMacroT m)
-> Monad (JMacroT m)
-> (forall a. JMacroT m a)
-> (forall a. JMacroT m a -> JMacroT m a -> JMacroT m a)
-> MonadPlus (JMacroT m)
JMacroT m a -> JMacroT m a -> JMacroT m a
forall a. JMacroT m a
forall a. JMacroT m a -> JMacroT m a -> JMacroT m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall (m :: * -> *). MonadPlus m => Monad (JMacroT m)
forall (m :: * -> *). MonadPlus m => Alternative (JMacroT m)
forall (m :: * -> *) a. MonadPlus m => JMacroT m a
forall (m :: * -> *) a.
MonadPlus m =>
JMacroT m a -> JMacroT m a -> JMacroT m a
mplus :: JMacroT m a -> JMacroT m a -> JMacroT m a
$cmplus :: forall (m :: * -> *) a.
MonadPlus m =>
JMacroT m a -> JMacroT m a -> JMacroT m a
mzero :: JMacroT m a
$cmzero :: forall (m :: * -> *) a. MonadPlus m => JMacroT m a
$cp2MonadPlus :: forall (m :: * -> *). MonadPlus m => Monad (JMacroT m)
$cp1MonadPlus :: forall (m :: * -> *). MonadPlus m => Alternative (JMacroT m)
MonadPlus, MonadState s, MonadReader r, MonadWriter w, MonadRWS r w s, Monad (JMacroT m)
Monad (JMacroT m)
-> (forall a b. ((a -> JMacroT m b) -> JMacroT m a) -> JMacroT m a)
-> MonadCont (JMacroT m)
((a -> JMacroT m b) -> JMacroT m a) -> JMacroT m a
forall a b. ((a -> JMacroT m b) -> JMacroT m a) -> JMacroT m a
forall (m :: * -> *).
Monad m -> (forall a b. ((a -> m b) -> m a) -> m a) -> MonadCont m
forall (m :: * -> *). MonadCont m => Monad (JMacroT m)
forall (m :: * -> *) a b.
MonadCont m =>
((a -> JMacroT m b) -> JMacroT m a) -> JMacroT m a
callCC :: ((a -> JMacroT m b) -> JMacroT m a) -> JMacroT m a
$ccallCC :: forall (m :: * -> *) a b.
MonadCont m =>
((a -> JMacroT m b) -> JMacroT m a) -> JMacroT m a
$cp1MonadCont :: forall (m :: * -> *). MonadCont m => Monad (JMacroT m)
MonadCont, MonadError e)

instance MonadTrans JMacroT where
    lift :: m a -> JMacroT m a
lift = m a -> JMacroT m a
forall (m :: * -> *) a. m a -> JMacroT m a
JMacroT

-- | map a function over the inner monad
mapJMacroT :: (m a -> n b) -> JMacroT m a -> JMacroT n b
mapJMacroT :: (m a -> n b) -> JMacroT m a -> JMacroT n b
mapJMacroT m a -> n b
f (JMacroT m a
ma) = n b -> JMacroT n b
forall (m :: * -> *) a. m a -> JMacroT m a
JMacroT (m a -> n b
f m a
ma)

-- | unwrap the 'XMLGenT' and 'JMacroT' constructors
evalJMacroT :: XMLGenT (JMacroT m) JExpr -> m JExpr
evalJMacroT :: XMLGenT (JMacroT m) JExpr -> m JExpr
evalJMacroT = JMacroT m JExpr -> m JExpr
forall (m :: * -> *) a. JMacroT m a -> m a
unJMacroT (JMacroT m JExpr -> m JExpr)
-> (XMLGenT (JMacroT m) JExpr -> JMacroT m JExpr)
-> XMLGenT (JMacroT m) JExpr
-> m JExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XMLGenT (JMacroT m) JExpr -> JMacroT m JExpr
forall (m :: * -> *) a. XMLGenT m a -> m a
unXMLGenT

-- | an alias for 'JMacroT Identity'
type JMacroM = JMacroT Identity

-- | evaluate 'JMacroM'
evalJMacroM :: XMLGenT JMacroM a -> a
evalJMacroM :: XMLGenT JMacroM a -> a
evalJMacroM = Identity a -> a
forall a. Identity a -> a
runIdentity (Identity a -> a)
-> (XMLGenT JMacroM a -> Identity a) -> XMLGenT JMacroM a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JMacroT Identity a -> Identity a
forall (m :: * -> *) a. JMacroT m a -> m a
unJMacroT (JMacroT Identity a -> Identity a)
-> (XMLGenT JMacroM a -> JMacroT Identity a)
-> XMLGenT JMacroM a
-> Identity a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XMLGenT JMacroM a -> JMacroT Identity a
forall (m :: * -> *) a. XMLGenT m a -> m a
unXMLGenT

instance (ToJExpr a) => ToJExpr (XMLGenT JMacroM a) where
    toJExpr :: XMLGenT JMacroM a -> JExpr
toJExpr = a -> JExpr
forall a. ToJExpr a => a -> JExpr
toJExpr (a -> JExpr)
-> (XMLGenT JMacroM a -> a) -> XMLGenT JMacroM a -> JExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XMLGenT JMacroM a -> a
forall a. XMLGenT JMacroM a -> a
evalJMacroM

instance (Functor m, Monad m) => XMLGen (JMacroT m) where
    type XMLType          (JMacroT m) = JExpr
    type StringType (JMacroT m) = Lazy.Text
    newtype ChildType     (JMacroT m) = JMChild { ChildType (JMacroT m) -> JExpr
unJMChild :: JExpr }
    newtype AttributeType (JMacroT m) = JMAttr  { AttributeType (JMacroT m) -> JExpr
unJMAttr  :: JExpr }
    genElement :: Name (StringType (JMacroT m))
-> [XMLGenT (JMacroT m) [AttributeType (JMacroT m)]]
-> [XMLGenT (JMacroT m) [ChildType (JMacroT m)]]
-> XMLGenT (JMacroT m) (XMLType (JMacroT m))
genElement        = Name (StringType (JMacroT m))
-> [XMLGenT (JMacroT m) [AttributeType (JMacroT m)]]
-> [XMLGenT (JMacroT m) [ChildType (JMacroT m)]]
-> XMLGenT (JMacroT m) (XMLType (JMacroT m))
forall (m :: * -> *) attr child.
(Functor m, Monad m, EmbedAsAttr (JMacroT m) attr,
 EmbedAsChild (JMacroT m) child) =>
Name Text -> [attr] -> [child] -> XMLGenT (JMacroT m) JExpr
element
    xmlToChild :: XMLType (JMacroT m) -> ChildType (JMacroT m)
xmlToChild        = XMLType (JMacroT m) -> ChildType (JMacroT m)
forall (m :: * -> *). JExpr -> ChildType (JMacroT m)
JMChild
    pcdataToChild :: StringType (JMacroT m) -> ChildType (JMacroT m)
pcdataToChild StringType (JMacroT m)
str = JExpr -> ChildType (JMacroT m)
forall (m :: * -> *). JExpr -> ChildType (JMacroT m)
JMChild (JExpr -> ChildType (JMacroT m)) -> JExpr -> ChildType (JMacroT m)
forall a b. (a -> b) -> a -> b
$ [jmacroE| document.createTextNode(`(Lazy.unpack str)`) |]


-- | generate an XML Element
element :: (Functor m, Monad m, EmbedAsAttr (JMacroT m) attr, EmbedAsChild (JMacroT m) child) =>
           Name Lazy.Text    -- ^ element name
        -> [attr]  -- ^ attributes
        -> [child] -- ^ children
        -> XMLGenT (JMacroT m) JExpr
element :: Name Text -> [attr] -> [child] -> XMLGenT (JMacroT m) JExpr
element (Maybe Text
ns, Text
nm) [attr]
attrs [child]
childer =
    do [JExpr]
ats      <- ([[AttributeType (JMacroT m)]] -> [JExpr])
-> XMLGenT (JMacroT m) [[AttributeType (JMacroT m)]]
-> XMLGenT (JMacroT m) [JExpr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((AttributeType (JMacroT m) -> JExpr)
-> [AttributeType (JMacroT m)] -> [JExpr]
forall a b. (a -> b) -> [a] -> [b]
map AttributeType (JMacroT m) -> JExpr
forall (m :: * -> *). AttributeType (JMacroT m) -> JExpr
unJMAttr  ([AttributeType (JMacroT m)] -> [JExpr])
-> ([[AttributeType (JMacroT m)]] -> [AttributeType (JMacroT m)])
-> [[AttributeType (JMacroT m)]]
-> [JExpr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[AttributeType (JMacroT m)]] -> [AttributeType (JMacroT m)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat) (XMLGenT (JMacroT m) [[AttributeType (JMacroT m)]]
 -> XMLGenT (JMacroT m) [JExpr])
-> XMLGenT (JMacroT m) [[AttributeType (JMacroT m)]]
-> XMLGenT (JMacroT m) [JExpr]
forall a b. (a -> b) -> a -> b
$ (attr -> XMLGenT (JMacroT m) [AttributeType (JMacroT m)])
-> [attr] -> XMLGenT (JMacroT m) [[AttributeType (JMacroT m)]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM attr -> XMLGenT (JMacroT m) [AttributeType (JMacroT m)]
forall (m :: * -> *) a. EmbedAsAttr m a => a -> GenAttributeList m
asAttr  [attr]
attrs
       [JExpr]
children <- ([[ChildType (JMacroT m)]] -> [JExpr])
-> XMLGenT (JMacroT m) [[ChildType (JMacroT m)]]
-> XMLGenT (JMacroT m) [JExpr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((ChildType (JMacroT m) -> JExpr)
-> [ChildType (JMacroT m)] -> [JExpr]
forall a b. (a -> b) -> [a] -> [b]
map ChildType (JMacroT m) -> JExpr
forall (m :: * -> *). ChildType (JMacroT m) -> JExpr
unJMChild ([ChildType (JMacroT m)] -> [JExpr])
-> ([[ChildType (JMacroT m)]] -> [ChildType (JMacroT m)])
-> [[ChildType (JMacroT m)]]
-> [JExpr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[ChildType (JMacroT m)]] -> [ChildType (JMacroT m)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat) (XMLGenT (JMacroT m) [[ChildType (JMacroT m)]]
 -> XMLGenT (JMacroT m) [JExpr])
-> XMLGenT (JMacroT m) [[ChildType (JMacroT m)]]
-> XMLGenT (JMacroT m) [JExpr]
forall a b. (a -> b) -> a -> b
$ (child -> XMLGenT (JMacroT m) [ChildType (JMacroT m)])
-> [child] -> XMLGenT (JMacroT m) [[ChildType (JMacroT m)]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM child -> XMLGenT (JMacroT m) [ChildType (JMacroT m)]
forall (m :: * -> *) c. EmbedAsChild m c => c -> GenChildList m
asChild [child]
childer
       JExpr -> XMLGenT (JMacroT m) JExpr
forall (m :: * -> *) a. Monad m => a -> m a
return
        [jmacroE| (function { var node = `(createElement (fmap Lazy.unpack ns) (Lazy.unpack nm))`;
                              `(map (setAttributeNode node) ats)`;
                              `(map (appendChild node) children)`;
                              return node;
                            })()
         |]

-- | javascript to create an element
createElement :: Maybe a -> a -> JExpr
createElement Maybe a
Nothing a
n = [jmacroE| document.createElement(`(n)`) |]
createElement (Just a
ns) a
n = [jmacroE| document.createElementNS(`(ns)`, `(n)`) |]

-- | javascript to append a child to an element
appendChild :: JExpr -> JExpr -> JExpr
appendChild :: JExpr -> JExpr -> JExpr
appendChild JExpr
node JExpr
c =
  [jmacroE| `(node)`.appendChild(`(c)`) |]

-- | javascript to set the attribute node of an element
setAttributeNode :: JExpr -> JExpr -> JExpr
setAttributeNode :: JExpr -> JExpr -> JExpr
setAttributeNode JExpr
node JExpr
attr =
    [jmacroE| `(node)`.setAttributeNode(`(attr)`) |]

instance (Functor m, Monad m) => EmbedAsAttr (JMacroT m) (Attr Lazy.Text Lazy.Text) where
    asAttr :: Attr Text Text -> GenAttributeList (JMacroT m)
asAttr (Text
n := Text
v) =
        [AttributeType (JMacroT m)] -> GenAttributeList (JMacroT m)
forall (m :: * -> *) a. Monad m => a -> m a
return [JExpr -> AttributeType (JMacroT m)
forall (m :: * -> *). JExpr -> AttributeType (JMacroT m)
JMAttr [jmacroE| (function (){ var attrNode = document.createAttribute(`(Lazy.unpack n)`)
                                             ; attrNode.nodeValue = `(Lazy.unpack v)`
                                             ; return attrNode;
                                             })()
                       |]]

instance (Functor m, Monad m, StringType (JMacroT m) ~ Lazy.Text) => EmbedAsChild (JMacroT m) Char where
    asChild :: Char -> GenChildList (JMacroT m)
asChild Char
c = [ChildType (JMacroT m)] -> GenChildList (JMacroT m)
forall (m :: * -> *) a. Monad m => a -> m a
return [StringType (JMacroT m) -> ChildType (JMacroT m)
forall (m :: * -> *). XMLGen m => StringType m -> ChildType m
pcdataToChild (StringType (JMacroT m) -> ChildType (JMacroT m))
-> StringType (JMacroT m) -> ChildType (JMacroT m)
forall a b. (a -> b) -> a -> b
$ Char -> Text
Lazy.singleton Char
c]

instance (Functor m, Monad m, StringType (JMacroT m) ~ Lazy.Text) => EmbedAsChild (JMacroT m) String where
    asChild :: String -> GenChildList (JMacroT m)
asChild String
str = [ChildType (JMacroT m)] -> GenChildList (JMacroT m)
forall (m :: * -> *) a. Monad m => a -> m a
return [StringType (JMacroT m) -> ChildType (JMacroT m)
forall (m :: * -> *). XMLGen m => StringType m -> ChildType m
pcdataToChild (StringType (JMacroT m) -> ChildType (JMacroT m))
-> StringType (JMacroT m) -> ChildType (JMacroT m)
forall a b. (a -> b) -> a -> b
$ String -> Text
Lazy.pack String
str]

instance (Functor m, Monad m) => EmbedAsChild (JMacroT m) Strict.Text where
    asChild :: Text -> GenChildList (JMacroT m)
asChild Text
txt = [ChildType (JMacroT m)] -> GenChildList (JMacroT m)
forall (m :: * -> *) a. Monad m => a -> m a
return [JExpr -> ChildType (JMacroT m)
forall (m :: * -> *). JExpr -> ChildType (JMacroT m)
JMChild (JExpr -> ChildType (JMacroT m)) -> JExpr -> ChildType (JMacroT m)
forall a b. (a -> b) -> a -> b
$ [jmacroE| document.createTextNode(`(Strict.unpack txt)`) |]]

instance (Functor m, Monad m) => EmbedAsChild (JMacroT m) Lazy.Text where
    asChild :: Text -> GenChildList (JMacroT m)
asChild Text
txt = [ChildType (JMacroT m)] -> GenChildList (JMacroT m)
forall (m :: * -> *) a. Monad m => a -> m a
return [JExpr -> ChildType (JMacroT m)
forall (m :: * -> *). JExpr -> ChildType (JMacroT m)
JMChild (JExpr -> ChildType (JMacroT m)) -> JExpr -> ChildType (JMacroT m)
forall a b. (a -> b) -> a -> b
$ [jmacroE| document.createTextNode(`(Lazy.unpack txt)`) |]]

instance (Functor m, Monad m) => EmbedAsChild (JMacroT m) () where
    asChild :: () -> GenChildList (JMacroT m)
asChild () = [ChildType (JMacroT m)] -> GenChildList (JMacroT m)
forall (m :: * -> *) a. Monad m => a -> m a
return []

instance (Functor m, Monad m) => EmbedAsAttr (JMacroT m) (Attr Lazy.Text Bool) where
    asAttr :: Attr Text Bool -> GenAttributeList (JMacroT m)
asAttr (Text
n := Bool
True)  = Attr Text Text -> GenAttributeList (JMacroT m)
forall (m :: * -> *) a. EmbedAsAttr m a => a -> GenAttributeList m
asAttr (Text
n Text -> Text -> Attr Text Text
forall n a. n -> a -> Attr n a
:= (Text
"true" :: Lazy.Text))
    asAttr (Text
n := Bool
False) = Attr Text Text -> GenAttributeList (JMacroT m)
forall (m :: * -> *) a. EmbedAsAttr m a => a -> GenAttributeList m
asAttr (Text
n Text -> Text -> Attr Text Text
forall n a. n -> a -> Attr n a
:= (Text
"false" :: Lazy.Text))

instance (Functor m, Monad m) => EmbedAsAttr (JMacroT m) (Attr Lazy.Text Int) where
    asAttr :: Attr Text Int -> GenAttributeList (JMacroT m)
asAttr (Text
n := Int
v) = Attr Text Text -> GenAttributeList (JMacroT m)
forall (m :: * -> *) a. EmbedAsAttr m a => a -> GenAttributeList m
asAttr (Text
n Text -> Text -> Attr Text Text
forall n a. n -> a -> Attr n a
:= (String -> Text
Lazy.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Int -> String
forall a. Show a => a -> String
show Int
v))

instance (Functor m, Monad m) => AppendChild (JMacroT m) JExpr where
    appChild :: JExpr -> GenChild (JMacroT m) -> GenXML (JMacroT m)
appChild JExpr
parent GenChild (JMacroT m)
child =
        do ChildType (JMacroT m)
c <- GenChild (JMacroT m)
child
           JExpr -> XMLGenT (JMacroT m) JExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (JExpr -> XMLGenT (JMacroT m) JExpr)
-> JExpr -> XMLGenT (JMacroT m) JExpr
forall a b. (a -> b) -> a -> b
$ [jmacroE| appendChild parent (unJMChild c) |]
    appAll :: JExpr -> GenChildList (JMacroT m) -> GenXML (JMacroT m)
appAll JExpr
parent GenChildList (JMacroT m)
children =
        do [ChildType (JMacroT m)]
chs <- GenChildList (JMacroT m)
children
           JExpr -> XMLGenT (JMacroT m) JExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (JExpr -> XMLGenT (JMacroT m) JExpr)
-> JExpr -> XMLGenT (JMacroT m) JExpr
forall a b. (a -> b) -> a -> b
$ [jmacroE| `(map (appendChild parent) (map unJMChild chs))` |]

instance (Functor m, Monad m) => SetAttr (JMacroT m) JExpr where
    setAttr :: JExpr -> GenAttribute (JMacroT m) -> GenXML (JMacroT m)
setAttr JExpr
elem GenAttribute (JMacroT m)
attrNode =
        do AttributeType (JMacroT m)
a <- GenAttribute (JMacroT m)
attrNode
           JExpr -> XMLGenT (JMacroT m) JExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (JExpr -> XMLGenT (JMacroT m) JExpr)
-> JExpr -> XMLGenT (JMacroT m) JExpr
forall a b. (a -> b) -> a -> b
$ [jmacroE| `(setAttributeNode elem (unJMAttr a))` |]
    setAll :: JExpr -> GenAttributeList (JMacroT m) -> GenXML (JMacroT m)
setAll JExpr
elem GenAttributeList (JMacroT m)
attrNodes =
        do [AttributeType (JMacroT m)]
as <- GenAttributeList (JMacroT m)
attrNodes
           JExpr -> XMLGenT (JMacroT m) JExpr
forall (m :: * -> *) a. Monad m => a -> m a
return (JExpr -> XMLGenT (JMacroT m) JExpr)
-> JExpr -> XMLGenT (JMacroT m) JExpr
forall a b. (a -> b) -> a -> b
$ [jmacroE| `(map (setAttributeNode elem) (map unJMAttr as))` |]

instance (Functor m, Monad m, StringType (JMacroT m) ~ Lazy.Text) => XMLGenerator (JMacroT m)