Text.Html.Nice.Internal

Documentation

type AttrName = Text

data Attr a

Constructors

(:=)

Fields

• attrKey :: !AttrName
• attrVal :: !Text

(:-)

Fields

• attrKey :: !AttrName
• attrValHole :: a

Instances

Functor Attr

Methods

fmap :: (a -> b) -> Attr a -> Attr b

(<$) :: a -> Attr b -> Attr a

Foldable Attr

Methods

fold :: Monoid m => Attr m -> m

foldMap :: Monoid m => (a -> m) -> Attr a -> m

foldr :: (a -> b -> b) -> b -> Attr a -> b

foldr' :: (a -> b -> b) -> b -> Attr a -> b

foldl :: (b -> a -> b) -> b -> Attr a -> b

foldl' :: (b -> a -> b) -> b -> Attr a -> b

foldr1 :: (a -> a -> a) -> Attr a -> a

foldl1 :: (a -> a -> a) -> Attr a -> a

toList :: Attr a -> [a]

null :: Attr a -> Bool

length :: Attr a -> Int

elem :: Eq a => a -> Attr a -> Bool

maximum :: Ord a => Attr a -> a

minimum :: Ord a => Attr a -> a

sum :: Num a => Attr a -> a

product :: Num a => Attr a -> a

Traversable Attr

Methods

traverse :: Applicative f => (a -> f b) -> Attr a -> f (Attr b)

sequenceA :: Applicative f => Attr (f a) -> f (Attr a)

mapM :: Monad m => (a -> m b) -> Attr a -> m (Attr b)

sequence :: Monad m => Attr (m a) -> m (Attr a)

Eq a => Eq (Attr a)

Methods

(==) :: Attr a -> Attr a -> Bool

(/=) :: Attr a -> Attr a -> Bool

Show a => Show (Attr a)

Methods

showsPrec :: Int -> Attr a -> ShowS

show :: Attr a -> String

showList :: [Attr a] -> ShowS

data IsEscaped

Constructors

DoEscape

Don'tEscape

Instances

Eq IsEscaped

Methods

(==) :: IsEscaped -> IsEscaped -> Bool

(/=) :: IsEscaped -> IsEscaped -> Bool

Show IsEscaped

Methods

showsPrec :: Int -> IsEscaped -> ShowS

show :: IsEscaped -> String

showList :: [IsEscaped] -> ShowS

data SomeText

Constructors

LazyT Text

BuilderT Builder

StrictT !Text

Instances

Eq SomeText

Methods

(==) :: SomeText -> SomeText -> Bool

(/=) :: SomeText -> SomeText -> Bool

Show SomeText

Methods

showsPrec :: Int -> SomeText -> ShowS

show :: SomeText -> String

showList :: [SomeText] -> ShowS

data Markup' a

A very simple HTML DSL

Constructors

Doctype

Node !Text !(Vector (Attr a)) (Markup' a)

VoidNode !Text !(Vector (Attr a))

List [Markup' a]

Stream (Stream a)

Text !IsEscaped !SomeText

Hole !IsEscaped a

Empty

Instances

Functor Markup'

Methods

fmap :: (a -> b) -> Markup' a -> Markup' b

(<$) :: a -> Markup' b -> Markup' a

Foldable Markup'

Methods

fold :: Monoid m => Markup' m -> m

foldMap :: Monoid m => (a -> m) -> Markup' a -> m

foldr :: (a -> b -> b) -> b -> Markup' a -> b

foldr' :: (a -> b -> b) -> b -> Markup' a -> b

foldl :: (b -> a -> b) -> b -> Markup' a -> b

foldl' :: (b -> a -> b) -> b -> Markup' a -> b

foldr1 :: (a -> a -> a) -> Markup' a -> a

foldl1 :: (a -> a -> a) -> Markup' a -> a

toList :: Markup' a -> [a]

null :: Markup' a -> Bool

length :: Markup' a -> Int

elem :: Eq a => a -> Markup' a -> Bool

maximum :: Ord a => Markup' a -> a

minimum :: Ord a => Markup' a -> a

sum :: Num a => Markup' a -> a

product :: Num a => Markup' a -> a

Eq a => Eq (Markup' a)

Methods

(==) :: Markup' a -> Markup' a -> Bool

(/=) :: Markup' a -> Markup' a -> Bool

Show a => Show (Markup' a)

Methods

showsPrec :: Int -> Markup' a -> ShowS

show :: Markup' a -> String

showList :: [Markup' a] -> ShowS

Recursive (Markup' a0)

Methods

project :: Markup' a0 -> Base (Markup' a0) (Markup' a0)

cata :: (Base (Markup' a0) a -> a) -> Markup' a0 -> a

para :: (Base (Markup' a0) (Markup' a0, a) -> a) -> Markup' a0 -> a

gpara :: (Corecursive (Markup' a0), Comonad w) => (forall b. Base (Markup' a0) (w b) -> w (Base (Markup' a0) b)) -> (Base (Markup' a0) (EnvT (Markup' a0) w a) -> a) -> Markup' a0 -> a

prepro :: Corecursive (Markup' a0) => (forall b. Base (Markup' a0) b -> Base (Markup' a0) b) -> (Base (Markup' a0) a -> a) -> Markup' a0 -> a

gprepro :: (Corecursive (Markup' a0), Comonad w) => (forall b. Base (Markup' a0) (w b) -> w (Base (Markup' a0) b)) -> (forall c. Base (Markup' a0) c -> Base (Markup' a0) c) -> (Base (Markup' a0) (w a) -> a) -> Markup' a0 -> a

Corecursive (Markup' a0)

Methods

embed :: Base (Markup' a0) (Markup' a0) -> Markup' a0

ana :: (a -> Base (Markup' a0) a) -> a -> Markup' a0

apo :: (a -> Base (Markup' a0) (Either (Markup' a0) a)) -> a -> Markup' a0

postpro :: Recursive (Markup' a0) => (forall b. Base (Markup' a0) b -> Base (Markup' a0) b) -> (a -> Base (Markup' a0) a) -> a -> Markup' a0

gpostpro :: (Recursive (Markup' a0), Monad m) => (forall b. m (Base (Markup' a0) b) -> Base (Markup' a0) (m b)) -> (forall c. Base (Markup' a0) c -> Base (Markup' a0) c) -> (a -> Base (Markup' a0) (m a)) -> a -> Markup' a0

type Base (Markup' a0)

type Base (Markup' a0) = Markup'F a0

data Stream a

Constructors

ListS [s] !(FastMarkup (s -> a))

Instances

Functor Stream

Methods

fmap :: (a -> b) -> Stream a -> Stream b

(<$) :: a -> Stream b -> Stream a

Foldable Stream

Methods

fold :: Monoid m => Stream m -> m

foldMap :: Monoid m => (a -> m) -> Stream a -> m

foldr :: (a -> b -> b) -> b -> Stream a -> b

foldr' :: (a -> b -> b) -> b -> Stream a -> b

foldl :: (b -> a -> b) -> b -> Stream a -> b

foldl' :: (b -> a -> b) -> b -> Stream a -> b

foldr1 :: (a -> a -> a) -> Stream a -> a

foldl1 :: (a -> a -> a) -> Stream a -> a

toList :: Stream a -> [a]

null :: Stream a -> Bool

length :: Stream a -> Int

elem :: Eq a => a -> Stream a -> Bool

maximum :: Ord a => Stream a -> a

minimum :: Ord a => Stream a -> a

sum :: Num a => Stream a -> a

product :: Num a => Stream a -> a

Eq (Stream a)

Don't use this! It's a lie!

Methods

(==) :: Stream a -> Stream a -> Bool

(/=) :: Stream a -> Stream a -> Bool

Show a => Show (Stream a)

Methods

showsPrec :: Int -> Stream a -> ShowS

show :: Stream a -> String

showList :: [Stream a] -> ShowS

NFData a => NFData (Stream a)

Methods

rnf :: Stream a -> ()

unstream :: (FastMarkup a -> b) -> Stream a -> (b -> c -> c) -> c -> c

data a :$ b infixl 0

Constructors

(:$) (FastMarkup (a -> b)) a infixl 0

Instances

Functor ((:$) a)

Methods

fmap :: (a -> b) -> (a :$ a) -> a :$ b

(<$) :: a -> (a :$ b) -> a :$ a

Show a => Show ((:$) a b)

Methods

showsPrec :: Int -> (a :$ b) -> ShowS

show :: (a :$ b) -> String

showList :: [a :$ b] -> ShowS

(Monad m, Render b m) => Render ((:$) a b) m

Defer application of an argument to rendering

Methods

r :: (a :$ b) -> m Builder

data FastMarkup a

Constructors

Bunch !(Vector (FastMarkup a))

FStream !(Stream a)

FHole !IsEscaped !a

FLText Text

FSText !Text

FBuilder !Builder

FEmpty

FDeep (FastMarkup (FastMarkup a))

Instances

Functor FastMarkup

Methods

fmap :: (a -> b) -> FastMarkup a -> FastMarkup b

(<$) :: a -> FastMarkup b -> FastMarkup a

Foldable FastMarkup

Methods

fold :: Monoid m => FastMarkup m -> m

foldMap :: Monoid m => (a -> m) -> FastMarkup a -> m

foldr :: (a -> b -> b) -> b -> FastMarkup a -> b

foldr' :: (a -> b -> b) -> b -> FastMarkup a -> b

foldl :: (b -> a -> b) -> b -> FastMarkup a -> b

foldl' :: (b -> a -> b) -> b -> FastMarkup a -> b

foldr1 :: (a -> a -> a) -> FastMarkup a -> a

foldl1 :: (a -> a -> a) -> FastMarkup a -> a

toList :: FastMarkup a -> [a]

null :: FastMarkup a -> Bool

length :: FastMarkup a -> Int

elem :: Eq a => a -> FastMarkup a -> Bool

maximum :: Ord a => FastMarkup a -> a

minimum :: Ord a => FastMarkup a -> a

sum :: Num a => FastMarkup a -> a

product :: Num a => FastMarkup a -> a

Eq a => Eq (FastMarkup a)

Methods

(==) :: FastMarkup a -> FastMarkup a -> Bool

(/=) :: FastMarkup a -> FastMarkup a -> Bool

Show a => Show (FastMarkup a)

Methods

showsPrec :: Int -> FastMarkup a -> ShowS

show :: FastMarkup a -> String

showList :: [FastMarkup a] -> ShowS

Generic (FastMarkup a)

Associated Types

type Rep (FastMarkup a) :: * -> *

Methods

from :: FastMarkup a -> Rep (FastMarkup a) x

to :: Rep (FastMarkup a) x -> FastMarkup a

Monoid (FastMarkup a)

Methods

mempty :: FastMarkup a

mappend :: FastMarkup a -> FastMarkup a -> FastMarkup a

mconcat :: [FastMarkup a] -> FastMarkup a

NFData a => NFData (FastMarkup a)

Methods

rnf :: FastMarkup a -> ()

(Render a m, Monad m) => Render (FastMarkup a) m

Methods

r :: FastMarkup a -> m Builder

type Rep (FastMarkup a)

type Rep (FastMarkup a) = D1 (MetaData "FastMarkup" "Text.Html.Nice.Internal" "nice-html-0.3.0-FPvZVt0dNb03fE7NHgRw8L" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Bunch" PrefixI False) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 (Vector (FastMarkup a))))) (C1 (MetaCons "FStream" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Stream a))))) ((:+:) (C1 (MetaCons "FHole" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 IsEscaped)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))) (C1 (MetaCons "FLText" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))))) ((:+:) ((:+:) (C1 (MetaCons "FSText" PrefixI False) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Text))) (C1 (MetaCons "FBuilder" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Builder)))) ((:+:) (C1 (MetaCons "FEmpty" PrefixI False) U1) (C1 (MetaCons "FDeep" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (FastMarkup (FastMarkup a))))))))

data Markup'F a r

Constructors

DoctypeF

NodeF !Text !(Vector (Attr a)) r

VoidNodeF !Text !(Vector (Attr a))

ListF [r]

StreamF (Stream a)

TextF !IsEscaped !SomeText

HoleF !IsEscaped a

EmptyF

Instances

Bifunctor Markup'F

Methods

bimap :: (a -> b) -> (c -> d) -> Markup'F a c -> Markup'F b d

first :: (a -> b) -> Markup'F a c -> Markup'F b c

second :: (b -> c) -> Markup'F a b -> Markup'F a c

Functor (Markup'F a0)

Methods

fmap :: (a -> b) -> Markup'F a0 a -> Markup'F a0 b

(<$) :: a -> Markup'F a0 b -> Markup'F a0 a

Foldable (Markup'F a0)

Methods

fold :: Monoid m => Markup'F a0 m -> m

foldMap :: Monoid m => (a -> m) -> Markup'F a0 a -> m

foldr :: (a -> b -> b) -> b -> Markup'F a0 a -> b

foldr' :: (a -> b -> b) -> b -> Markup'F a0 a -> b

foldl :: (b -> a -> b) -> b -> Markup'F a0 a -> b

foldl' :: (b -> a -> b) -> b -> Markup'F a0 a -> b

foldr1 :: (a -> a -> a) -> Markup'F a0 a -> a

foldl1 :: (a -> a -> a) -> Markup'F a0 a -> a

toList :: Markup'F a0 a -> [a]

null :: Markup'F a0 a -> Bool

length :: Markup'F a0 a -> Int

elem :: Eq a => a -> Markup'F a0 a -> Bool

maximum :: Ord a => Markup'F a0 a -> a

minimum :: Ord a => Markup'F a0 a -> a

sum :: Num a => Markup'F a0 a -> a

product :: Num a => Markup'F a0 a -> a

Traversable (Markup'F a0)

Methods

traverse :: Applicative f => (a -> f b) -> Markup'F a0 a -> f (Markup'F a0 b)

sequenceA :: Applicative f => Markup'F a0 (f a) -> f (Markup'F a0 a)

mapM :: Monad m => (a -> m b) -> Markup'F a0 a -> m (Markup'F a0 b)

sequence :: Monad m => Markup'F a0 (m a) -> m (Markup'F a0 a)

MonadFree (Markup'F n) (Markup n)

Methods

wrap :: Markup'F n (Markup n a) -> Markup n a

plateFM :: Monad m => (FastMarkup a -> m (FastMarkup a)) -> FastMarkup a -> m (FastMarkup a)

Unlike plate, this uses Monad. That's because traverse over Vector is really quite slow.

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

immediateRender :: FastMarkup a -> Maybe Builder

Look for an immediate string-like term and render that

munch :: Vector (FastMarkup a) -> Vector (FastMarkup a)

Flatten a vector of 'FastMarkup. String-like terms that are next to eachother should be combined

flatten :: FastMarkup a -> FastMarkup a

Recursively flatten FastMarkup until doing so does nothing

strictify :: FastMarkup a -> FastMarkup a

Run all Text builders

compile_ :: Markup' a -> FastMarkup a

Compile Markup''

recompile :: FastMarkup a -> FastMarkup a

unlayer :: FastMarkup (FastMarkup a) -> FastMarkup a

renderM :: Monad m => (a -> m Builder) -> FastMarkup a -> m Builder

Render FastMarkup

renderMs :: Monad m => (a -> m (FastMarkup Void)) -> FastMarkup a -> m Builder

Render FastMarkup by recursively rendering any sub-markup.

render :: FastMarkup Void -> Builder

Render FastMarkup that has no holes.

class Render a m where

Minimal complete definition

r

Methods

r :: a -> m Builder

Instances

Monad m => Render Void m

Methods

r :: Void -> m Builder

Monad m => Render Text m

Methods

r :: Text -> m Builder

Monad m => Render Text m

Methods

r :: Text -> m Builder

Monad m => Render Builder m

Methods

r :: Builder -> m Builder

(Render a m, Monad m) => Render (FastMarkup a) m

Methods

r :: FastMarkup a -> m Builder

(ToFastMarkup a, Monad m) => Render (RenderToFastMarkup a) m

Methods

r :: RenderToFastMarkup a -> m Builder

(Render b m, (~) (* -> *) m' (ReaderT * a m)) => Render (a -> b) m'

Methods

r :: (a -> b) -> m' Builder

(Monad m, Render b m) => Render ((:$) a b) m

Defer application of an argument to rendering

Methods

r :: (a :$ b) -> m Builder

newtype RenderToFastMarkup a

Constructors

RenderToFastMarkup

Fields

• unToFastMarkup :: a

Instances

(ToFastMarkup a, Monad m) => Render (RenderToFastMarkup a) m

Methods

r :: RenderToFastMarkup a -> m Builder

class ToFastMarkup a where

Minimal complete definition

toFastMarkup

Methods

toFastMarkup :: a -> FastMarkup b

Instances

ToFastMarkup Text

Methods

toFastMarkup :: Text -> FastMarkup b

ToFastMarkup Text

Methods

toFastMarkup :: Text -> FastMarkup b

ToFastMarkup Builder

Methods

toFastMarkup :: Builder -> FastMarkup b

RealFloat a => ToFastMarkup (AsRealFloat a)

Methods

toFastMarkup :: AsRealFloat a -> FastMarkup b

Integral a => ToFastMarkup (AsHex a)

Methods

toFastMarkup :: AsHex a -> FastMarkup b

Integral a => ToFastMarkup (AsDecimal a)

Methods

toFastMarkup :: AsDecimal a -> FastMarkup b

newtype AsDecimal a

Constructors

AsDecimal

Fields

• asDecimal :: a

Instances

Integral a => ToFastMarkup (AsDecimal a)

Methods

toFastMarkup :: AsDecimal a -> FastMarkup b

newtype AsHex a

Constructors

AsHex

Fields

• asHex :: a

Instances

Integral a => ToFastMarkup (AsHex a)

Methods

toFastMarkup :: AsHex a -> FastMarkup b

newtype AsRealFloat a

Constructors

AsRealFloat

Fields

• asRealFloat :: a

Instances

RealFloat a => ToFastMarkup (AsRealFloat a)

Methods

toFastMarkup :: AsRealFloat a -> FastMarkup b