Text.Hastache.Context

Hastache context helpers

Documentation

mkStrContext :: Monad m => (String -> MuType m) -> MuContext m

Make Hastache context from String -> MuType function

mkStrContextM :: Monad m => (String -> m (MuType m)) -> MuContext m

Make Hastache context from monadic String -> MuType function

mkGenericContext :: (Monad m, Data a, Typeable m) => a -> MuContext m

Make Hastache context from Data.Data deriving type

Supported field types:

• String
• Char
• Double
• Float
• Int
• Int8
• Int16
• Int32
• Int64
• Integer
• Word
• Word8
• Word16
• Word32
• Word64
• Data.ByteString.ByteString
• Data.ByteString.Lazy.ByteString
• Data.Text.Text
• Data.Text.Lazy.Text
• Bool
• Data.Text.Text -> Data.Text.Text
• Data.Text.Text -> Data.Text.Lazy.Text
• Data.Text.Lazy.Text -> Data.Text.Lazy.Text
• Data.ByteString.ByteString -> Data.ByteString.ByteString
• String -> String
• Data.ByteString.ByteString -> Data.ByteString.Lazy.ByteString
• MonadIO m => Data.Text.Text -> m Data.Text.Text
• MonadIO m => Data.Text.Text -> m Data.Text.Lazy.Text
• MonadIO m => Data.Text.Lazy.Text -> m Data.Text.Lazy.Text
• MonadIO m => Data.ByteString.ByteString -> m Data.ByteString.ByteString
• MonadIO m => String -> m String
• MonadIO m => Data.ByteString.ByteString -> m Data.ByteString.Lazy.ByteString

Example:

import Text.Hastache 
import Text.Hastache.Context
import qualified Data.Text as T
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.IO as TL
import Data.Data 
import Data.Generics 
import Data.Char

data InternalData = InternalData {
    someField       :: String,
    anotherField    :: Int
    } deriving (Data, Typeable, Show)

data Example = Example {
    stringField             :: String,
    intField                :: Int,
    dataField               :: InternalData,
    simpleListField         :: [String],
    dataListField           :: [InternalData],
    stringFunc              :: String -> String,
    textFunc                :: T.Text -> T.Text,
    monadicStringFunc       :: String -> IO String,
    monadicTextFunc         :: T.Text -> IO T.Text
    } deriving (Data, Typeable)

example = hastacheStr defaultConfig (encodeStr template) 
    (mkGenericContext context)
    where
    template = concat $ map (++ "\n") [
        "string: {{stringField}}",
        "int: {{intField}}",
        "data: {{dataField.someField}}, {{dataField.anotherField}}",
        "data: {{#dataField}}{{someField}}, {{anotherField}}{{/dataField}}",
        "simple list: {{#simpleListField}}{{.}} {{/simpleListField}}",
        "data list:",
        "{{#dataListField}}",
        " * {{someField}}, {{anotherField}}. top level var: {{intField}}",
        "{{/dataListField}}",
        "{{#stringFunc}}upper{{/stringFunc}}",
        "{{#textFunc}}reverse{{/textFunc}}",
        "{{#monadicStringFunc}}upper (monadic){{/monadicStringFunc}}",
        "{{#monadicTextFunc}}reverse (monadic){{/monadicTextFunc}}"]
    context = Example { stringField = "string value", intField = 1, 
        dataField = InternalData "val" 123, simpleListField = ["a","b","c"],
        dataListField = [InternalData "aaa" 1, InternalData "bbb" 2],
        stringFunc = map toUpper,
        textFunc = T.reverse,
        monadicStringFunc = return . map toUpper,
        monadicTextFunc = return . T.reverse }

main = example >>= TL.putStrLn

Result:

string: string value 
int: 1 
data: val, 123 
data: val, 123 
simple list: a b c  
data list: 
 * aaa, 1. top level var: 1 
 * bbb, 2. top level var: 1 
UPPER 
esrever 
UPPER (MONADIC)
)cidanom( esrever

Hastache also supports datatypes with multiple constructors:

data A = A { str :: String }
       | B { num :: Int }

{{#A}}
A : {{str}}
{{/A}}
{{#B}}
B : {{num}}
{{/B}}