diff --git a/bin/Class.hs b/bin/Class.hs
--- a/bin/Class.hs
+++ b/bin/Class.hs
@@ -74,16 +74,16 @@
 	varE $ mkName "ParseError"
 
 parseErrorT :: Bool -> DecQ
-parseErrorT _ = flip (dataD (cxt []) (mkName "ParseError")
-		[PlainTV $ mkName "pos", PlainTV $ mkName "drv"])
-	[] $ [	recC (mkName "ParseError") [
+parseErrorT _ = dataD (cxt []) (mkName "ParseError")
+		[PlainTV $ mkName "pos", PlainTV $ mkName "drv"] Nothing
+	[	recC (mkName "ParseError") [
 			varStrictType c strT,
 			varStrictType m strT,
 			varStrictType com strT,
 			varStrictType d drvT,
 			varStrictType r lstT,
 			varStrictType pos posT ]
-	 ]
+	 ] (cxt [])
 	where
 	[c, m, com, r, d, pos] = map mkName [
 		"peCode",
@@ -248,7 +248,7 @@
 instanceSrcStr _ =
 	instanceD (cxt [classP sourceList [varT c]]) (conT source `appT` listC) [
 		tySynInstD tokenN $ tySynEqn [listC] (varT c),
-		flip (newtypeInstD (cxt []) posN [listC]) [] $
+		flip (newtypeInstD (cxt []) posN [listC] Nothing) (cxt []) $
 			normalC listPosN [strictType notStrict $
 				conT listPosN `appT` varT c],
 		valD (varP getTokenN) (normalB $ varE listTokenN) [],
@@ -307,12 +307,12 @@
 -}
 
 instanceSLC th = instanceD (cxt []) (conT sourceList `appT` conT (charN th)) [
-	newtypeInstD (cxt []) listPosN [conT $ charN th] (
+	newtypeInstD (cxt []) listPosN [conT $ charN th] Nothing (
 		normalC (mkName "CharPos") [
 			strictType notStrict $ tupleT 2
 				`appT` conT (mkName "Int")
 				`appT` conT (mkName "Int")]
-	 ) [mkName "Show"],
+	 ) (cxt [conT $ mkName "Show"]),
 	funD listTokenN [
 		clause [infixP (varP c) (consN th) (varP s)]
 			(normalB $ conE (justN th) `appE` tupleBody) [],
diff --git a/papillon.cabal b/papillon.cabal
--- a/papillon.cabal
+++ b/papillon.cabal
@@ -2,7 +2,7 @@
 cabal-version:	>= 1.8
 
 name:		papillon
-version:	0.1.0.3
+version:	0.1.0.4
 stability:	Experimental
 author:		Yoshikuni Jujo <PAF01143@nifty.ne.jp>
 maintainer:	Yoshikuni Jujo <PAF01143@nifty.ne.jp>
@@ -39,8 +39,8 @@
     Text.Papillon.Papillon,
     Text.Papillon.List
   build-depends:
-    base > 3 && < 5, template-haskell == 2.10.*,
-    monads-tf == 0.1.*, transformers == 0.4.*,
+    base > 3 && < 5, template-haskell == 2.11.*,
+    monads-tf == 0.1.*, transformers == 0.5.*,
     bytestring == 0.10.*
   ghc-options:		-Wall -fno-warn-tabs
 
@@ -49,6 +49,6 @@
   main-is:		papillon.hs
   other-modules:	Class
   build-depends:
-    directory, filepath, base > 3 && < 5, template-haskell == 2.10.*,
-    monads-tf == 0.1.*, transformers == 0.4.*, papillon
+    directory, filepath, base > 3 && < 5, template-haskell == 2.11.*,
+    monads-tf == 0.1.*, transformers == 0.5.*, papillon
   ghc-options:		-Wall -fno-warn-tabs
diff --git a/src/Text/Papillon/Core.hs b/src/Text/Papillon/Core.hs
--- a/src/Text/Papillon/Core.hs
+++ b/src/Text/Papillon/Core.hs
@@ -92,19 +92,22 @@
 		pt = SigD (mkPrName prefix "parse") $
 			src `arrT` ConT (mkPrUName prefix "Derivs")
 	p <- funD (mkPrName prefix "parse") [mkParseBody th (isJust monad) prefix parsed]
-	return [d, pt, p]
+	d' <- d
+	return [d', pt, p]
 
-derivs :: Bool -> Type -> Type -> String -> Peg -> Dec
-derivs th monad src prefix pg = DataD [] (mkPrUName prefix "Derivs") [] [
-	RecC (mkPrUName prefix "Derivs") $ map derivs1 pg ++ [
-		(mkPrName prefix dvCharsN, NotStrict, resultT tkn),
-		(dvPosN prefix, NotStrict, resultT $ ConT (mkName "Pos") `AppT` src)
-	 ]] []
+derivs :: Bool -> Type -> Type -> String -> Peg -> DecQ
+derivs th monad src prefix pg = do
+	ns <- notStrict
+	return $ DataD [] (mkPrUName prefix "Derivs") [] Nothing [
+		RecC (mkPrUName prefix "Derivs") $ map (derivs1 ns) pg ++ [
+			(mkPrName prefix dvCharsN, ns, resultT tkn),
+			(dvPosN prefix, ns, resultT $ ConT (mkName "Pos") `AppT` src)
+		]] []
 	where
 	tkn = ConT (mkName "Token") `AppT` src
-	derivs1 (name, Just t, _) = (mkPrName prefix name, NotStrict, resultT t)
-	derivs1 (name, Nothing, _) =
-		(mkPrName prefix name, NotStrict, resultT $ TupleT 0)
+	derivs1 ns (name, Just t, _) = (mkPrName prefix name, ns, resultT t)
+	derivs1 ns (name, Nothing, _) =
+		(mkPrName prefix name, ns, resultT $ TupleT 0)
 	resultT typ = ConT (errorTTN th)
 		`AppT` (ConT (mkName "ParseError")
 			`AppT` (ConT (mkName "Pos") `AppT` src)