diff --git a/Text/Hastache.hs b/Text/Hastache.hs
--- a/Text/Hastache.hs
+++ b/Text/Hastache.hs
@@ -358,7 +358,7 @@
 -- | Render Hastache template from file
 hastacheFile :: (MonadIO m) => 
     MuConfig            -- ^ Configuration
-    -> String           -- ^ Template file name
+    -> FilePath         -- ^ Template file name
     -> MuContext m      -- ^ Context
     -> m LZ.ByteString
 hastacheFile conf file_name context = do
diff --git a/Text/Hastache/Context.hs b/Text/Hastache/Context.hs
--- a/Text/Hastache/Context.hs
+++ b/Text/Hastache/Context.hs
@@ -44,13 +44,15 @@
     } deriving (Data, Typeable, Show)
 
 data Example = Example {
-    stringField     :: String,
-    intField        :: Int,
-    dataField       :: InternalData,
-    simpleListField :: [String],
-    dataListField   :: [InternalData],
-    stringFunc      :: String -> String,
-    byteStringFunc  :: Data.ByteString.ByteString -> Data.ByteString.ByteString
+    stringField             :: String,
+    intField                :: Int,
+    dataField               :: InternalData,
+    simpleListField         :: [String],
+    dataListField           :: [InternalData],
+    stringFunc              :: String -> String,
+    byteStringFunc          :: Data.ByteString.ByteString -> Data.ByteString.ByteString,
+    monadicStringFunc       :: String -> IO String,
+    monadicByteStringFunc   :: Data.ByteString.ByteString -> IO Data.ByteString.ByteString
     } deriving (Data, Typeable)
 
 example = hastacheStr defaultConfig (encodeStr template) 
@@ -67,12 +69,18 @@
         \" * {{someField}}, {{anotherField}}. top level var: {{intField}}\",
         \"{{/dataListField}}\",
         \"{{#stringFunc}}upper{{/stringFunc}}\",
-        \"{{#byteStringFunc}}reverse{{/byteStringFunc}}\"]
+        \"{{#byteStringFunc}}reverse{{/byteStringFunc}}\",
+        \"{{#monadicStringFunc}}upper (monadic){{/monadicStringFunc}}\",
+        \"{{#monadicByteStringFunc}}reverse (monadic){{/monadicByteStringFunc}}\"]
     context = Example { stringField = \"string value\", intField = 1, 
         dataField = InternalData \"val\" 123, simpleListField = [\"a\",\"b\",\"c\"],
         dataListField = [InternalData \"aaa\" 1, InternalData \"bbb\" 2],
         stringFunc = map Data.Char.toUpper,
-        byteStringFunc = Data.ByteString.reverse }
+        byteStringFunc = Data.ByteString.reverse,
+        monadicStringFunc = return . map Data.Char.toUpper,
+        monadicByteStringFunc = return . Data.ByteString.reverse }
+
+main = example >>= Data.ByteString.Lazy.putStrLn
 @
 
 Result:
@@ -88,9 +96,11 @@
  * bbb, 2. top level var: 1 
 UPPER 
 esrever 
+UPPER (MONADIC)
+)cidanom( esrever
 @
 -}
-mkGenericContext :: (Monad m, Data a) => a -> MuContext m
+mkGenericContext :: (Monad m, Data a, Typeable1 m) => a -> MuContext m
 mkGenericContext val = toGenTemp val ~> convertGenTempToContext
     
 data TD m = 
@@ -100,12 +110,12 @@
     | TUnknown
     deriving (Show)
 
-toGenTemp :: (Data a, Monad m) => a -> TD m
+toGenTemp :: (Data a, Monad m, Typeable1 m) => a -> TD m
 toGenTemp a = zip fields (gmapQ procField a) ~> TObj
     where
     fields = toConstr a ~> constrFields
 
-procField :: (Data a, Monad m) => a -> TD m
+procField :: (Data a, Monad m, Typeable1 m) => a -> TD m
 procField = 
     obj
     `ext1Q` list
@@ -131,13 +141,25 @@
     `extQ` (\(i::Bool)              -> MuBool i ~> TSimple)
     `extQ` muLambdaBS
     `extQ` muLambdaS
+    `extQ` muLambdaMBS
+    `extQ` muLambdaMS
     where
     obj a = case dataTypeRep (dataTypeOf a) of
         AlgRep [c] -> toGenTemp a
         _ -> TUnknown
     list a = map procField a ~> TList
+
+    muLambdaMBS :: (BS.ByteString -> m BS.ByteString) -> TD m
+    muLambdaMBS f = MuLambdaM f ~> TSimple
+
+    muLambdaMS :: forall m. Monad m => (String -> m String) -> TD m
+    muLambdaMS f = MuLambdaM fd ~> TSimple
+        where
+        fd s = decodeStr s ~> f >>= return . encodeStr
+
     muLambdaBS :: (BS.ByteString -> BS.ByteString) -> TD m
     muLambdaBS f = MuLambda f ~> TSimple
+
     muLambdaS :: (String -> String) -> TD m
     muLambdaS f = MuLambda fd ~> TSimple
         where
diff --git a/hastache.cabal b/hastache.cabal
--- a/hastache.cabal
+++ b/hastache.cabal
@@ -1,5 +1,5 @@
 name:            hastache
-version:         0.1.5
+version:         0.1.6
 license:         BSD3
 license-file:    LICENSE
 category:        Text
diff --git a/tests/test.hs b/tests/test.hs
--- a/tests/test.hs
+++ b/tests/test.hs
@@ -251,7 +251,9 @@
     someDataList        :: [Int],
     someDataObjList     :: [InternalData],
     someMuLambdaBS      :: BS.ByteString -> BS.ByteString,
-    someMuLambdaS       :: String -> String
+    someMuLambdaS       :: String -> String,
+    someMuLambdaMBS     :: BS.ByteString -> IO BS.ByteString,
+    someMuLambdaMS      :: String -> IO String
     }
     deriving (Data, Typeable)
 
@@ -278,6 +280,8 @@
         \{{/someDataObjList}}\n\
         \{{#someMuLambdaBS}}reverse{{/someMuLambdaBS}}\n\
         \{{#someMuLambdaS}}upper{{/someMuLambdaS}}\n\
+        \{{#someMuLambdaMBS}}reverse in IO lambda{{/someMuLambdaMBS}}\n\
+        \{{#someMuLambdaMS}}upper in IO lambda{{/someMuLambdaMS}}\n\
         \text 2\n\
         \"
     context = SomeData {
@@ -288,7 +292,9 @@
         someDataObjList = [InternalData "a" 1, InternalData "b" 2,
             InternalData "c" 3],
         someMuLambdaBS = BS.reverse,
-        someMuLambdaS = map toUpper
+        someMuLambdaS = map toUpper,
+        someMuLambdaMBS = return . BS.reverse,
+        someMuLambdaMS = return . map toUpper
         }
     
     testRes = "\
@@ -306,6 +312,8 @@
         \* c : 3 \n\
         \esrever\n\
         \UPPER\n\
+        \adbmal OI ni esrever\n\
+        \UPPER IN IO LAMBDA\n\
         \text 2\n\
         \"
 
@@ -334,6 +342,7 @@
         \ * elem 2. top\n\
         \"
 
+-- Up-level context from nested block (Generic version)
 data TopData = TopData {
     topDataTop          :: String,
     topDataItems        :: [NestedData]
@@ -345,7 +354,6 @@
     }
     deriving (Data, Typeable)
 
--- Up-level context from nested block (Generic version)
 nestedGenericContextTest = do
     res <- hastacheStr defaultConfig (encodeStr template) context
     assertEqualStr "result correctness" (decodeStrLBS res) testRes