{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE CPP #-}
#if MIN_VERSION_blaze_markup(0,7,1)
#define PRE_BUILDER
#endif
module Text.BlazeT.Internal
(
MarkupT(..)
,MarkupI
,mapMarkupT
,MarkupM
,Markup
,Markup2
,runMarkupT
,runMarkup
,runWith
,execMarkupT
,execMarkup
,execWith
,wrapMarkupT
,wrapMarkupT2
,wrapMarkup
,wrapMarkup2
,
Text.Blaze.ChoiceString (..)
, Text.Blaze.StaticString (..)
, Text.Blaze.Tag
, Text.Blaze.Attribute
, Text.Blaze.AttributeValue
, customParent
, customLeaf
, Text.Blaze.attribute
, Text.Blaze.dataAttribute
, Text.Blaze.customAttribute
, text
, preEscapedText
, lazyText
, preEscapedLazyText
, textBuilder
, preEscapedTextBuilder
, string
, preEscapedString
, unsafeByteString
, unsafeLazyByteString
, textComment
, lazyTextComment
, stringComment
, unsafeByteStringComment
, unsafeLazyByteStringComment
, Text.Blaze.textTag
, Text.Blaze.stringTag
, Text.Blaze.textValue
, Text.Blaze.preEscapedTextValue
, Text.Blaze.lazyTextValue
, Text.Blaze.preEscapedLazyTextValue
, Text.Blaze.textBuilderValue
, Text.Blaze.preEscapedTextBuilderValue
, Text.Blaze.stringValue
, Text.Blaze.preEscapedStringValue
, Text.Blaze.unsafeByteStringValue
, Text.Blaze.unsafeLazyByteStringValue
, Text.Blaze.Attributable
, (Text.Blaze.!)
, (Text.Blaze.!?)
, contents
, external
, null
) where
import Control.Arrow
import Control.Monad.Identity
import Control.Monad.Trans.Class
import Control.Monad.Writer.Strict
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as BL
import Data.String
import qualified Data.Text as T
import qualified Data.Text.Lazy as LT
import qualified Data.Text.Lazy.Builder as LTB
import qualified Text.Blaze
import qualified Text.Blaze.Internal as Text.Blaze
newtype MarkupT m a= MarkupT { forall (m :: * -> *) a. MarkupT m a -> WriterT Markup m a
fromMarkupT :: WriterT Text.Blaze.Markup m a }
deriving (forall a b. a -> MarkupT m b -> MarkupT m a
forall a b. (a -> b) -> MarkupT m a -> MarkupT m b
forall (m :: * -> *) a b.
Functor m =>
a -> MarkupT m b -> MarkupT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> MarkupT m a -> MarkupT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> MarkupT m b -> MarkupT m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> MarkupT m b -> MarkupT m a
fmap :: forall a b. (a -> b) -> MarkupT m a -> MarkupT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> MarkupT m a -> MarkupT m b
Functor
#if MIN_VERSION_base(4,8,0)
,forall a. a -> MarkupT m a
forall a b. MarkupT m a -> MarkupT m b -> MarkupT m a
forall a b. MarkupT m a -> MarkupT m b -> MarkupT m b
forall a b. MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b
forall a b c.
(a -> b -> c) -> MarkupT m a -> MarkupT m b -> MarkupT 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 (MarkupT m)
forall (m :: * -> *) a. Applicative m => a -> MarkupT m a
forall (m :: * -> *) a b.
Applicative m =>
MarkupT m a -> MarkupT m b -> MarkupT m a
forall (m :: * -> *) a b.
Applicative m =>
MarkupT m a -> MarkupT m b -> MarkupT m b
forall (m :: * -> *) a b.
Applicative m =>
MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> MarkupT m a -> MarkupT m b -> MarkupT m c
<* :: forall a b. MarkupT m a -> MarkupT m b -> MarkupT m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
MarkupT m a -> MarkupT m b -> MarkupT m a
*> :: forall a b. MarkupT m a -> MarkupT m b -> MarkupT m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
MarkupT m a -> MarkupT m b -> MarkupT m b
liftA2 :: forall a b c.
(a -> b -> c) -> MarkupT m a -> MarkupT m b -> MarkupT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> MarkupT m a -> MarkupT m b -> MarkupT m c
<*> :: forall a b. MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b
pure :: forall a. a -> MarkupT m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> MarkupT m a
Applicative
#endif
,forall a. a -> MarkupT m a
forall a b. MarkupT m a -> MarkupT m b -> MarkupT m b
forall a b. MarkupT m a -> (a -> MarkupT m b) -> MarkupT m b
forall {m :: * -> *}. Monad m => Applicative (MarkupT m)
forall (m :: * -> *) a. Monad m => a -> MarkupT m a
forall (m :: * -> *) a b.
Monad m =>
MarkupT m a -> MarkupT m b -> MarkupT m b
forall (m :: * -> *) a b.
Monad m =>
MarkupT m a -> (a -> MarkupT m b) -> MarkupT 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 :: forall a. a -> MarkupT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> MarkupT m a
>> :: forall a b. MarkupT m a -> MarkupT m b -> MarkupT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
MarkupT m a -> MarkupT m b -> MarkupT m b
>>= :: forall a b. MarkupT m a -> (a -> MarkupT m b) -> MarkupT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
MarkupT m a -> (a -> MarkupT m b) -> MarkupT m b
Monad
,MonadWriter Text.Blaze.Markup
,forall (m :: * -> *) a. Monad m => m a -> MarkupT m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: forall (m :: * -> *) a. Monad m => m a -> MarkupT m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> MarkupT m a
MonadTrans
)
type MarkupI a = MarkupT Identity a
mapMarkupT :: (m (a,Text.Blaze.Markup) -> n (b,Text.Blaze.Markup)) -> MarkupT m a -> MarkupT n b
mapMarkupT :: forall (m :: * -> *) a (n :: * -> *) b.
(m (a, Markup) -> n (b, Markup)) -> MarkupT m a -> MarkupT n b
mapMarkupT m (a, Markup) -> n (b, Markup)
f = forall (m :: * -> *) a. WriterT Markup m a -> MarkupT m a
MarkupT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
mapWriterT m (a, Markup) -> n (b, Markup)
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> WriterT Markup m a
fromMarkupT
{-# INLINE mapMarkupT #-}
type MarkupM a = forall m . Monad m => MarkupT m a
type Markup = MarkupM ()
type Markup2 = forall m . Monad m => MarkupT m () -> MarkupT m ()
runMarkupT :: MarkupT m a -> m (a,Text.Blaze.Markup)
runMarkupT :: forall (m :: * -> *) a. MarkupT m a -> m (a, Markup)
runMarkupT = forall w (m :: * -> *) a. WriterT w m a -> m (a, w)
runWriterT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> WriterT Markup m a
fromMarkupT
{-# INLINE runMarkupT #-}
runWith :: Monad m => (MarkupI () -> c) -> MarkupT m a -> m (a, c)
runWith :: forall (m :: * -> *) c a.
Monad m =>
(MarkupI () -> c) -> MarkupT m a -> m (a, c)
runWith MarkupI () -> c
renderer = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second forall a b. (a -> b) -> a -> b
$ MarkupI () -> c
renderer forall b c a. (b -> c) -> (a -> b) -> a -> c
. Markup -> Markup
wrapMarkup) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> m (a, Markup)
runMarkupT
{-# INLINE runWith #-}
execMarkupT :: Monad m => MarkupT m a -> m Text.Blaze.Markup
execMarkupT :: forall (m :: * -> *) a. Monad m => MarkupT m a -> m Markup
execMarkupT = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> m (a, Markup)
runMarkupT
{-# INLINE execMarkupT #-}
execWith :: Monad m => (MarkupI () -> c) -> MarkupT m a -> m c
execWith :: forall (m :: * -> *) c a.
Monad m =>
(MarkupI () -> c) -> MarkupT m a -> m c
execWith MarkupI () -> c
renderer = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) c a.
Monad m =>
(MarkupI () -> c) -> MarkupT m a -> m (a, c)
runWith MarkupI () -> c
renderer
{-# INLINE execWith #-}
runMarkup :: MarkupI a -> (a, Text.Blaze.Markup)
runMarkup :: forall a. MarkupI a -> (a, Markup)
runMarkup = forall a. Identity a -> a
runIdentity forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> m (a, Markup)
runMarkupT
{-# INLINE runMarkup #-}
execMarkup :: MarkupI a -> Text.Blaze.Markup
execMarkup :: forall a. MarkupI a -> Markup
execMarkup = forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. MarkupI a -> (a, Markup)
runMarkup
{-# INLINE execMarkup #-}
wrapMarkupT :: Monad m => Text.Blaze.Markup -> MarkupT m ()
wrapMarkupT :: forall (m :: * -> *). Monad m => Markup -> MarkupT m ()
wrapMarkupT = forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell
{-# INLINE wrapMarkupT #-}
wrapMarkup :: Text.Blaze.Markup -> Markup
wrapMarkup :: Markup -> Markup
wrapMarkup = forall (m :: * -> *). Monad m => Markup -> MarkupT m ()
wrapMarkupT
{-# INLINE wrapMarkup #-}
wrapMarkupT2 :: Monad m => (Text.Blaze.Markup -> Text.Blaze.Markup)
-> MarkupT m a -> MarkupT m a
wrapMarkupT2 :: forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2 = forall w (m :: * -> *) a. MonadWriter w m => (w -> w) -> m a -> m a
censor
{-# INLINE wrapMarkupT2 #-}
wrapMarkup2 :: (Text.Blaze.Markup -> Text.Blaze.Markup) -> Markup2
wrapMarkup2 :: (Markup -> Markup) -> Markup2
wrapMarkup2 = forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2
{-# INLINE wrapMarkup2 #-}
mappendMarkupT
#if defined(MIN_VERSION_base)
# if MIN_VERSION_base(4, 11, 0)
:: (Monad m, Semigroup a)
# else
:: (Monad m, Monoid a)
# endif
#else
:: (Monad m, Monoid a)
#endif
=> MarkupT m a
-> MarkupT m a
-> MarkupT m a
MarkupT m a
a mappendMarkupT :: forall (m :: * -> *) a.
(Monad m, Semigroup a) =>
MarkupT m a -> MarkupT m a -> MarkupT m a
`mappendMarkupT` MarkupT m a
b = do {a
a' <- MarkupT m a
a; MarkupT m a
b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a
a' forall a. Semigroup a => a -> a -> a
<>)}
#if defined(MIN_VERSION_base)
# if MIN_VERSION_base(4, 11, 0)
instance (Monad m,Semigroup a) => Semigroup (MarkupT m a) where
<> :: MarkupT m a -> MarkupT m a -> MarkupT m a
(<>) = forall (m :: * -> *) a.
(Monad m, Semigroup a) =>
MarkupT m a -> MarkupT m a -> MarkupT m a
mappendMarkupT
{-# INLINE (<>) #-}
# else
instance (Monad m,Monoid a) => Monoid (MarkupT m a) where
mempty = return mempty
{-# INLINE mempty #-}
mappend = mappendMarkupT
{-# INLINE mappend #-}
# endif
#else
instance (Monad m,Monoid a) => Monoid (MarkupT m a) where
mempty = return mempty
{-# INLINE mempty #-}
mappend = mappendMarkupT
{-# INLINE mappend #-}
#endif
instance Monad m => Text.Blaze.Attributable (MarkupT m a) where
MarkupT m a
h ! :: MarkupT m a -> Attribute -> MarkupT m a
! Attribute
a = forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2 (forall h. Attributable h => h -> Attribute -> h
Text.Blaze.! Attribute
a) MarkupT m a
h
{-# INLINE (!) #-}
instance Monad m => Text.Blaze.Attributable (a -> MarkupT m b) where
a -> MarkupT m b
h ! :: (a -> MarkupT m b) -> Attribute -> a -> MarkupT m b
! Attribute
a = \a
x -> forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2 (forall h. Attributable h => h -> Attribute -> h
Text.Blaze.! Attribute
a) forall a b. (a -> b) -> a -> b
$ a -> MarkupT m b
h a
x
{-# INLINE (!) #-}
instance Monad m => IsString (MarkupT m ()) where
fromString :: String -> MarkupT m ()
fromString = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => String -> a
fromString
{-# INLINE fromString #-}
unsafeByteString :: BS.ByteString -> Markup
unsafeByteString :: ByteString -> Markup
unsafeByteString = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Markup
Text.Blaze.unsafeByteString
{-# INLINE unsafeByteString #-}
unsafeLazyByteString :: BL.ByteString
-> Markup
unsafeLazyByteString :: ByteString -> Markup
unsafeLazyByteString = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Markup
Text.Blaze.unsafeLazyByteString
{-# INLINE unsafeLazyByteString #-}
external :: Monad m => MarkupT m a -> MarkupT m a
external :: forall (m :: * -> *) a. Monad m => MarkupT m a -> MarkupT m a
external = forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2 forall a. MarkupM a -> MarkupM a
Text.Blaze.external
{-# INLINE external #-}
contents :: Monad m => MarkupT m a -> MarkupT m a
contents :: forall (m :: * -> *) a. Monad m => MarkupT m a -> MarkupT m a
contents = forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2 forall a. MarkupM a -> MarkupM a
Text.Blaze.contents
{-# INLINE contents #-}
customParent ::Text.Blaze.Tag -> Markup2
customParent :: Tag -> Markup2
customParent = (Markup -> Markup) -> Markup2
wrapMarkup2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tag -> Markup -> Markup
Text.Blaze.customParent
{-# INLINE customParent #-}
customLeaf :: Text.Blaze.Tag -> Bool -> Markup
customLeaf :: Tag -> Bool -> Markup
customLeaf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tag -> Bool -> Markup
Text.Blaze.customLeaf
{-# INLINE customLeaf #-}
preEscapedText :: T.Text -> Markup
preEscapedText :: Text -> Markup
preEscapedText = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.preEscapedText
{-# INLINE preEscapedText #-}
preEscapedLazyText :: LT.Text -> Markup
preEscapedLazyText :: Text -> Markup
preEscapedLazyText = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.preEscapedLazyText
{-# INLINE preEscapedLazyText #-}
preEscapedTextBuilder :: LTB.Builder -> Markup
textBuilder :: LTB.Builder -> Markup
#ifdef PRE_BUILDER
preEscapedTextBuilder :: Builder -> Markup
preEscapedTextBuilder = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Markup
Text.Blaze.preEscapedTextBuilder
textBuilder :: Builder -> Markup
textBuilder = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Markup
Text.Blaze.textBuilder
{-# INLINE preEscapedTextBuilder #-}
{-# INLINE textBuilder #-}
#else
preEscapedTextBuilder = error "This function needs blaze-markup 0.7.1.0"
textBuilder = error "This function needs blaze-markup 0.7.1.0"
#endif
preEscapedString :: String -> Markup
preEscapedString :: String -> Markup
preEscapedString = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Markup
Text.Blaze.preEscapedString
{-# INLINE preEscapedString #-}
string :: String -> Markup
string :: String -> Markup
string = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Markup
Text.Blaze.string
{-# INLINE string #-}
text :: T.Text -> Markup
text :: Text -> Markup
text = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.text
{-# INLINE text #-}
lazyText :: LT.Text -> Markup
lazyText :: Text -> Markup
lazyText = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.lazyText
{-# INLINE lazyText #-}
textComment :: T.Text -> Markup
= Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.textComment
lazyTextComment :: LT.Text -> Markup
= Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.lazyTextComment
stringComment :: String -> Markup
= Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Markup
Text.Blaze.stringComment
unsafeByteStringComment :: BS.ByteString -> Markup
= Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Markup
Text.Blaze.unsafeByteStringComment
unsafeLazyByteStringComment :: BL.ByteString -> Markup
= Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Markup
Text.Blaze.unsafeLazyByteStringComment