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


-- | Haml-like template files that are compile-time checked
--   
--   Hamlet gives you a type-safe tool for generating HTML code. It works
--   via Quasi-Quoting, and generating extremely efficient output code. The
--   syntax is white-space sensitive, and it helps you avoid cross-site
--   scripting issues and 404 errors. Please see the documentation at
--   <a>http://docs.yesodweb.com/book/hamlet/</a> for more details.
--   
--   Here is a quick overview of hamlet html. Due to haddock escaping
--   issues, we can't properly show variable insertion, but we are still
--   going to show some conditionals. Please see
--   http:<i></i>docs.yesodweb.com<i>book</i>templates for a thorough
--   description
--   
--   <pre>
--   !!!
--   &lt;html&gt;
--       &lt;head&gt;
--           &lt;title&gt;Hamlet Demo
--       &lt;body&gt;
--           &lt;h1&gt;Information on John Doe
--           &lt;h2&gt;
--               $if isMarried person
--                   Married
--               $else
--                   Not married
--   </pre>
@package hamlet
@version 0.8.1

module Text.Cassius
type Cassius url = (url -> [(Text, Text)] -> Text) -> Css
type Css = [CssTop]
class ToCss a
toCss :: ToCss a => a -> Builder
renderCassius :: (url -> [(Text, Text)] -> Text) -> Cassius url -> Text
renderCss :: Css -> Text
cassius :: QuasiQuoter
cassiusFile :: FilePath -> Q Exp
cassiusFileDebug :: FilePath -> Q Exp
data Color
Color :: Word8 -> Word8 -> Word8 -> Color
colorRed :: Color
colorBlack :: Color

-- | Create a CSS size, e.g. $(mkSize <a>100px</a>).
mkSize :: String -> ExpQ

-- | Absolute size units.
data AbsoluteUnit
Centimeter :: AbsoluteUnit
Inch :: AbsoluteUnit
Millimeter :: AbsoluteUnit
Pica :: AbsoluteUnit
Point :: AbsoluteUnit

-- | Not intended for direct use, see <a>mkSize</a>.
data AbsoluteSize
AbsoluteSize :: AbsoluteUnit -> Rational -> AbsoluteSize

-- | Units used for text formatting.
absoluteSizeUnit :: AbsoluteSize -> AbsoluteUnit

-- | Normalized value in centimeters.
absoluteSizeValue :: AbsoluteSize -> Rational

-- | Constructs <a>AbsoluteSize</a>. Not intended for direct use, see
--   <a>mkSize</a>.
absoluteSize :: AbsoluteUnit -> Rational -> AbsoluteSize
data EmSize
EmSize :: Rational -> EmSize
data ExSize
ExSize :: Rational -> ExSize

-- | Not intended for direct use, see <a>mkSize</a>.
data PercentageSize
PercentageSize :: Rational -> PercentageSize

-- | Normalized value, 1 == 100%.
percentageSizeValue :: PercentageSize -> Rational

-- | Constructs <a>PercentageSize</a>. Not intended for direct use, see
--   <a>mkSize</a>.
percentageSize :: Rational -> PercentageSize
data PixelSize
PixelSize :: Rational -> PixelSize
instance Eq PixelSize
instance Ord PixelSize
instance ToCss PixelSize
instance Fractional PixelSize
instance Num PixelSize
instance Show PixelSize
instance Eq ExSize
instance Ord ExSize
instance ToCss ExSize
instance Fractional ExSize
instance Num ExSize
instance Show ExSize
instance Eq EmSize
instance Ord EmSize
instance ToCss EmSize
instance Fractional EmSize
instance Num EmSize
instance Show EmSize
instance Show Color
instance Eq AbsoluteUnit
instance Show AbsoluteUnit
instance Eq PercentageSize
instance Ord PercentageSize
instance ToCss PercentageSize
instance Fractional PercentageSize
instance Num PercentageSize
instance Show PercentageSize
instance ToCss AbsoluteSize
instance Fractional AbsoluteSize
instance Num AbsoluteSize
instance Ord AbsoluteSize
instance Eq AbsoluteSize
instance Show AbsoluteSize
instance ToCss Color

module Text.Lucius
type Lucius a = Cassius a
renderLucius :: (url -> [(Text, Text)] -> Text) -> Lucius url -> Text

-- | <pre>
--   &gt;&gt;&gt; renderLucius undefined [lucius|foo{bar:baz}|]
--   "foo{bar:baz}"
--   </pre>
lucius :: QuasiQuoter
luciusFile :: FilePath -> Q Exp
luciusFileDebug :: FilePath -> Q Exp


-- | For lack of a better name... a parameterized version of Julius.
module Text.Romeo
data RomeoSettings
RomeoSettings :: Char -> Char -> Char -> Exp -> Exp -> Exp -> RomeoSettings
varChar :: RomeoSettings -> Char
urlChar :: RomeoSettings -> Char
intChar :: RomeoSettings -> Char
toBuilder :: RomeoSettings -> Exp
wrap :: RomeoSettings -> Exp
unwrap :: RomeoSettings -> Exp
defaultRomeoSettings :: RomeoSettings
romeo :: RomeoSettings -> QuasiQuoter
romeoFile :: RomeoSettings -> FilePath -> Q Exp
romeoFileDebug :: RomeoSettings -> FilePath -> Q Exp
instance Show Content
instance Eq Content
instance Lift RomeoSettings

module Text.Julius
type Julius url = (url -> [(Text, Text)] -> Text) -> Javascript
newtype Javascript
Javascript :: Builder -> Javascript
unJavascript :: Javascript -> Builder
class ToJavascript a
toJavascript :: ToJavascript a => a -> Builder
renderJulius :: (url -> [(Text, Text)] -> Text) -> Julius url -> Text
julius :: QuasiQuoter
juliusFile :: FilePath -> Q Exp
juliusFileDebug :: FilePath -> Q Exp
instance Monoid Javascript
instance ToJavascript Text
instance ToJavascript Text
instance ToJavascript [Char]

module Text.Coffee
class ToCoffee c
toCoffee :: ToCoffee c => c -> Builder
type Coffee url = (url -> [(Text, Text)] -> Text) -> Coffeescript
coffee :: QuasiQuoter
coffeeFile :: FilePath -> Q Exp
coffeeFileDebug :: FilePath -> Q Exp
renderCoffee :: (url -> [(Text, Text)] -> Text) -> Coffee url -> IO Text
instance Monoid Coffeescript
instance ToCoffee Text
instance ToCoffee Text
instance ToCoffee [Char]


-- | Most everything exported here is exported also by <a>Text.Hamlet</a>.
--   The exceptions to that rule should not be necessary for normal usage.
module Text.Hamlet.RT
newtype HamletRT
HamletRT :: [SimpleDoc] -> HamletRT
data HamletData url
HDHtml :: Html -> HamletData url
HDUrl :: url -> HamletData url
HDUrlParams :: url -> [(Text, Text)] -> HamletData url
HDTemplate :: HamletRT -> HamletData url
HDBool :: Bool -> HamletData url
HDMaybe :: (Maybe (HamletMap url)) -> HamletData url
HDList :: [HamletMap url] -> HamletData url
type HamletMap url = [([String], HamletData url)]
data HamletException
HamletParseException :: String -> HamletException
HamletUnsupportedDocException :: Doc -> HamletException
HamletRenderException :: String -> HamletException
parseHamletRT :: Failure HamletException m => HamletSettings -> String -> m HamletRT
renderHamletRT :: Failure HamletException m => HamletRT -> HamletMap url -> (url -> [(Text, Text)] -> Text) -> m Html
renderHamletRT' :: Failure HamletException m => Bool -> HamletRT -> HamletMap url -> (url -> [(Text, Text)] -> Text) -> m Html
data SimpleDoc
SDRaw :: String -> SimpleDoc
SDVar :: [String] -> SimpleDoc
SDUrl :: Bool -> [String] -> SimpleDoc
SDTemplate :: [String] -> SimpleDoc
SDForall :: [String] -> String -> [SimpleDoc] -> SimpleDoc
SDMaybe :: [String] -> String -> [SimpleDoc] -> [SimpleDoc] -> SimpleDoc
SDCond :: [([String], [SimpleDoc])] -> [SimpleDoc] -> SimpleDoc
instance Typeable HamletException
instance Show HamletException
instance Exception HamletException

module Text.Hamlet.NonPoly

-- | Simplification of the <a>HtmlM</a> datatype.
type Html = HtmlM ()
html :: QuasiQuoter
htmlFile :: FilePath -> Q Exp

-- | A function generating an <a>Html</a> given a URL-rendering function.
type Hamlet url = Render url -> Html
hamlet :: QuasiQuoter
hamletFile :: FilePath -> Q Exp

-- | A function generating an <a>Html</a> given a message translator and a
--   URL rendering function.
type IHamlet msg url = Translate msg -> Render url -> Html
ihamlet :: QuasiQuoter
ihamletFile :: FilePath -> Q Exp
hamletWithSettings :: Q HamletRules -> HamletSettings -> QuasiQuoter
hamletFileWithSettings :: Q HamletRules -> HamletSettings -> FilePath -> Q Exp

-- | Defaults settings: HTML5 doctype and HTML-style empty tags.
defaultHamletSettings :: HamletSettings
data Env
Env :: Maybe ((Exp -> Q Exp) -> Q Exp) -> Maybe ((Exp -> Q Exp) -> Q Exp) -> Env
urlRender :: Env -> Maybe ((Exp -> Q Exp) -> Q Exp)
msgRender :: Env -> Maybe ((Exp -> Q Exp) -> Q Exp)
data HamletRules
HamletRules :: Exp -> ((Env -> Q Exp) -> Q Exp) -> HamletRules
hrFromHtml :: HamletRules -> Exp
hrWithEnv :: HamletRules -> (Env -> Q Exp) -> Q Exp

module Text.Hamlet

-- | Calls <a>hamletWithSettings</a> with <a>defaultHamletSettings</a>.
hamlet :: QuasiQuoter

-- | Calls <a>hamletWithSettings</a> using XHTML 1.0 Strict settings.
xhamlet :: QuasiQuoter

-- | Calls <a>hamletWithSettings</a> with <a>debugHamletSettings</a>.
hamletDebug :: QuasiQuoter

-- | Calls <a>hamletFileWithSettings</a> with <a>defaultHamletSettings</a>.
hamletFile :: FilePath -> Q Exp

-- | Calls <a>hamletFileWithSettings</a> using XHTML 1.0 Strict settings.
xhamletFile :: FilePath -> Q Exp
hamletFileDebug :: FilePath -> Q Exp

-- | A quasi-quoter that converts Hamlet syntax into a function of form:
--   
--   <pre>
--   (url -&gt; String) -&gt; Html
--   </pre>
--   
--   Please see accompanying documentation for a description of Hamlet
--   syntax.
hamletWithSettings :: HamletSettings -> QuasiQuoter
hamletFileWithSettings :: HamletSettings -> FilePath -> Q Exp

-- | Settings for parsing of a hamlet document.
data HamletSettings
HamletSettings :: String -> Bool -> (String -> CloseStyle) -> HamletSettings

-- | The value to replace a "!!!" with. Do not include the trailing
--   newline.
hamletDoctype :: HamletSettings -> String

-- | Should we put a newline after closing a tag? Mostly useful for debug
--   output.
hamletCloseNewline :: HamletSettings -> Bool

-- | How a tag should be closed. Use this to switch between HTML, XHTML or
--   even XML output.
hamletCloseStyle :: HamletSettings -> String -> CloseStyle

-- | Defaults settings: HTML5 doctype and HTML-style empty tags.
defaultHamletSettings :: HamletSettings
xhtmlHamletSettings :: HamletSettings

-- | Simplification of the <a>HtmlM</a> datatype.
type Html = HtmlM ()

-- | An function generating an <a>Html</a> given a URL-rendering function.
type Hamlet url = (url -> [(Text, Text)] -> Text) -> Html
class Monad (HamletMonad a) => HamletValue a where { data family HamletMonad a :: * -> *; type family HamletUrl a; }
toHamletValue :: HamletValue a => HamletMonad a () -> a
htmlToHamletMonad :: HamletValue a => Html -> HamletMonad a ()
urlToHamletMonad :: HamletValue a => HamletUrl a -> [(Text, Text)] -> HamletMonad a ()
fromHamletValue :: HamletValue a => a -> HamletMonad a ()

-- | Create an HTML snippet from a <a>String</a> without escaping
preEscapedString :: String -> Html

-- | Render text without escaping.
preEscapedText :: Text -> Html

-- | A variant of <a>preEscapedText</a> for lazy <a>Text</a>
preEscapedLazyText :: Text -> Html

-- | Create an HTML snippet from a <a>String</a>.
string :: String -> Html

-- | Insert a <a>ByteString</a>. This is an unsafe operation:
--   
--   <ul>
--   <li>The <a>ByteString</a> could have the wrong encoding.</li>
--   <li>The <a>ByteString</a> might contain illegal HTML characters (no
--   escaping is done).</li>
--   </ul>
unsafeByteString :: ByteString -> Html

-- | Wrap an <a>Html</a> for embedding in an XML file.
cdata :: Html -> Html

-- | Convert a value to HTML.
toHtml :: ToHtml a => a -> Html

-- | Converts a <a>Hamlet</a> to lazy bytestring.
renderHamlet :: (url -> [(Text, Text)] -> Text) -> Hamlet url -> ByteString

-- | Render HTML to a lazy UTF-8 encoded 'L.ByteString.'
renderHtml :: Html -> ByteString
renderHamletText :: (url -> [(Text, Text)] -> Text) -> Hamlet url -> Text
renderHtmlText :: Html -> Text
data HamletRT
data HamletData url
HDHtml :: Html -> HamletData url
HDUrl :: url -> HamletData url
HDUrlParams :: url -> [(Text, Text)] -> HamletData url
HDTemplate :: HamletRT -> HamletData url
HDBool :: Bool -> HamletData url
HDMaybe :: (Maybe (HamletMap url)) -> HamletData url
HDList :: [HamletMap url] -> HamletData url
data HamletException
HamletParseException :: String -> HamletException
HamletUnsupportedDocException :: Doc -> HamletException
HamletRenderException :: String -> HamletException
parseHamletRT :: Failure HamletException m => HamletSettings -> String -> m HamletRT
renderHamletRT :: Failure HamletException m => HamletRT -> HamletMap url -> (url -> [(Text, Text)] -> Text) -> m Html