diff --git a/Text/XML/Pugi.hs b/Text/XML/Pugi.hs
--- a/Text/XML/Pugi.hs
+++ b/Text/XML/Pugi.hs
@@ -10,6 +10,8 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE CPP #-}
 
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
 -- | import/langauge
 --
 -- @
@@ -163,67 +165,67 @@
 pretty :: D.PrettyConfig -> Document -> L.ByteString
 pretty cfg doc = unsafeDupablePerformIO $ D.pretty cfg doc
 
-instance Show (Node_ k Immutable) where
+instance Show (Node_ k 'Immutable) where
     show = ("Node " ++) . L8.unpack . prettyNode def {D.prettyFlags = formatRaw} 0
 
-instance Show (Document_ k Immutable) where
+instance Show (Document_ k 'Immutable) where
     show = ("Document " ++) . L8.unpack . prettyNode def {D.prettyFlags = formatRaw} 0
 
-instance Eq (Node_ k Immutable) where
+instance Eq (Node_ k 'Immutable) where
     (==) = nodeEqual
 
-instance Eq (Document_ k Immutable) where
+instance Eq (Document_ k 'Immutable) where
     (==) = nodeEqual
 
 class NodeLike n where
-    asNode                 :: n k Immutable -> Node_ k Immutable
-    nodeEqual              :: n k Immutable -> n l Immutable -> Bool
-    forgetNodeKind         :: n k Immutable -> n Unknown Immutable
+    asNode                 :: n k 'Immutable -> Node_ k 'Immutable
+    nodeEqual              :: n k 'Immutable -> n l 'Immutable -> Bool
+    forgetNodeKind         :: n k 'Immutable -> n 'Unknown 'Immutable
     forgetNodeKind = unsafeCoerce
     {-# INLINE forgetNodeKind #-}
-    prettyNode             :: D.PrettyConfig -> Int -> n k Immutable -> L.ByteString
-    hashValue              :: n k Immutable -> CSize
-    nodeType               :: n k Immutable -> NodeType
-    getName                :: HasName  k => n k Immutable -> S.ByteString
-    getValue               :: HasValue k => n k Immutable -> S.ByteString
-    parent                 :: n k Immutable -> Maybe Node
-    firstChild             :: HasChildren k => n k Immutable -> Maybe Node
-    lastChild              :: HasChildren k => n k Immutable -> Maybe Node
-    nextSibling            :: n k Immutable -> Maybe Node
-    prevSibling            :: n k Immutable -> Maybe Node
-    child                  :: HasChildren  k => S.ByteString -> n k Immutable -> Maybe Node
-    attribute              :: HasAttribute k => S.ByteString -> n k Immutable -> Maybe S.ByteString
-    nextSiblingByName      :: S.ByteString -> n k Immutable -> Maybe Node
-    prevSiblingByName      :: S.ByteString -> n k Immutable -> Maybe Node
+    prettyNode             :: D.PrettyConfig -> Int -> n k 'Immutable -> L.ByteString
+    hashValue              :: n k 'Immutable -> CSize
+    nodeType               :: n k 'Immutable -> NodeType
+    getName                :: HasName  k => n k 'Immutable -> S.ByteString
+    getValue               :: HasValue k => n k 'Immutable -> S.ByteString
+    parent                 :: n k 'Immutable -> Maybe Node
+    firstChild             :: HasChildren k => n k 'Immutable -> Maybe Node
+    lastChild              :: HasChildren k => n k 'Immutable -> Maybe Node
+    nextSibling            :: n k 'Immutable -> Maybe Node
+    prevSibling            :: n k 'Immutable -> Maybe Node
+    child                  :: HasChildren  k => S.ByteString -> n k 'Immutable -> Maybe Node
+    attribute              :: HasAttribute k => S.ByteString -> n k 'Immutable -> Maybe S.ByteString
+    nextSiblingByName      :: S.ByteString -> n k 'Immutable -> Maybe Node
+    prevSiblingByName      :: S.ByteString -> n k 'Immutable -> Maybe Node
     findChildByNameAndAttr :: HasChildren k
                            => S.ByteString -- ^ node name
                            -> S.ByteString -- ^ attribute name
                            -> S.ByteString -- ^ attribute value
-                           -> n k Immutable -> Maybe Node
+                           -> n k 'Immutable -> Maybe Node
     findChildByAttr        :: HasChildren k
                            => S.ByteString -- ^ attribute name
                            -> S.ByteString -- ^ attribute value
-                           -> n k Immutable -> Maybe Node
-    childValue             :: HasChildren k => n k Immutable -> S.ByteString
-    childValueByName       :: HasChildren k => S.ByteString -> n k Immutable -> S.ByteString
-    text                   :: n k Immutable -> S.ByteString
+                           -> n k 'Immutable -> Maybe Node
+    childValue             :: HasChildren k => n k 'Immutable -> S.ByteString
+    childValueByName       :: HasChildren k => S.ByteString -> n k 'Immutable -> S.ByteString
+    text                   :: n k 'Immutable -> S.ByteString
 
     -- | find attribute by predicate. since v0.2.0.
-    findAttribute          :: (S.ByteString -> S.ByteString -> Bool) -> n k Immutable -> Maybe Attribute
+    findAttribute          :: (S.ByteString -> S.ByteString -> Bool) -> n k 'Immutable -> Maybe Attribute
 
     -- | find child by predicate. since v0.2.0.
-    findChild              :: (Node -> Bool) -> n k Immutable -> Maybe Node
+    findChild              :: (Node -> Bool) -> n k 'Immutable -> Maybe Node
 
     -- | find node by predicate. since v0.2.0.
-    findNode               :: (Node -> Bool) -> n k Immutable -> Maybe Node
-    mapSibling             :: (Node_ Unknown Immutable -> a) -> n k Immutable -> [a]
-    mapAttrs               :: HasAttribute k => (S.ByteString -> S.ByteString -> a) -> n k Immutable -> [a]
-    path                   :: Char -> n k Immutable -> S.ByteString
-    firstElementByPath     :: Char -> S.ByteString -> n k Immutable -> Maybe Node
-    root                   :: n k Immutable -> Maybe Node
-    evaluate               :: X.EvalXPath r => XPath r -> n k Immutable -> (X.XPathResult r Immutable)
-    selectSingleNode       :: XPath NodeSet -> n k Immutable -> XPathNode Immutable
-    selectNodes            :: XPath NodeSet -> n k Immutable -> NodeSet Immutable
+    findNode               :: (Node -> Bool) -> n k 'Immutable -> Maybe Node
+    mapSibling             :: (Node_ 'Unknown 'Immutable -> a) -> n k 'Immutable -> [a]
+    mapAttrs               :: HasAttribute k => (S.ByteString -> S.ByteString -> a) -> n k 'Immutable -> [a]
+    path                   :: Char -> n k 'Immutable -> S.ByteString
+    firstElementByPath     :: Char -> S.ByteString -> n k 'Immutable -> Maybe Node
+    root                   :: n k 'Immutable -> Maybe Node
+    evaluate               :: X.EvalXPath r => XPath r -> n k 'Immutable -> (X.XPathResult r 'Immutable)
+    selectSingleNode       :: XPath NodeSet -> n k 'Immutable -> XPathNode 'Immutable
+    selectNodes            :: XPath NodeSet -> n k 'Immutable -> NodeSet 'Immutable
 
 instance NodeLike Document_ where
     asNode              = unsafeDupablePerformIO . N.asNode
@@ -296,27 +298,27 @@
     selectNodes x          = unsafeDupablePerformIO . N.selectNodes x
 
 class HasName (k :: NodeKind)
-instance HasName Element
-instance HasName Declaration
-instance HasName Pi
-instance HasName Unknown
+instance HasName 'Element
+instance HasName 'Declaration
+instance HasName 'Pi
+instance HasName 'Unknown
 
 class HasValue (k :: NodeKind)
-instance HasValue PCData
-instance HasValue CData
-instance HasValue Comment
-instance HasValue Doctype
-instance HasValue Pi
-instance HasValue Unknown
+instance HasValue 'PCData
+instance HasValue 'CData
+instance HasValue 'Comment
+instance HasValue 'Doctype
+instance HasValue 'Pi
+instance HasValue 'Unknown
 
 class HasAttribute (k :: NodeKind)
-instance HasAttribute Element
-instance HasAttribute Declaration
-instance HasAttribute Unknown
+instance HasAttribute 'Element
+instance HasAttribute 'Declaration
+instance HasAttribute 'Unknown
 
 class HasChildren (k :: NodeKind)
-instance HasChildren Element
-instance HasChildren Unknown
+instance HasChildren 'Element
+instance HasChildren 'Unknown
 
 nodeSetIndex :: NodeSet m -> Int -> XPathNode m
 nodeSetIndex n = unsafeDupablePerformIO . X.nodeSetIndex n
@@ -327,10 +329,10 @@
 nodeSetToList :: NodeSet m -> [XPathNode m]
 nodeSetToList = nodeSetMap id
 
-asMutable :: N.NodeLike n => n k Mutable -> n k Mutable
+asMutable :: N.NodeLike n => n k 'Mutable -> n k 'Mutable
 asMutable = id
 {-# INLINE asMutable #-}
 
-asImmutable :: N.NodeLike n => n k Immutable -> n k Immutable
+asImmutable :: N.NodeLike n => n k 'Immutable -> n k 'Immutable
 asImmutable = id
 {-# INLINE asImmutable #-}
diff --git a/Text/XML/Pugi/Foreign/Const.hs b/Text/XML/Pugi/Foreign/Const.hs
--- a/Text/XML/Pugi/Foreign/Const.hs
+++ b/Text/XML/Pugi/Foreign/Const.hs
@@ -1,4 +1,6 @@
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE CPP #-}
+
 module Text.XML.Pugi.Foreign.Const where
 
 import Foreign.C
@@ -6,7 +8,10 @@
 import Data.Default.Class
 import Data.Bits
 import Data.List
+
+#if !MIN_VERSION_base(4,8,0)
 import Data.Monoid
+#endif
 
 foreign import ccall unsafe pugixml_version :: CInt
 
diff --git a/Text/XML/Pugi/Foreign/Document.hs b/Text/XML/Pugi/Foreign/Document.hs
--- a/Text/XML/Pugi/Foreign/Document.hs
+++ b/Text/XML/Pugi/Foreign/Document.hs
@@ -1,10 +1,14 @@
 {-# LANGUAGE ForeignFunctionInterface #-}
 {-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE CPP #-}
+
 module Text.XML.Pugi.Foreign.Document where
 
-import Control.Applicative
 import Control.Monad
 import Control.Exception
+#if !MIN_VERSION_base(4,8,0)
+import Control.Applicative
+#endif
 
 import Foreign.C
 import Foreign.Ptr
diff --git a/Text/XML/Pugi/Foreign/Node.hs b/Text/XML/Pugi/Foreign/Node.hs
--- a/Text/XML/Pugi/Foreign/Node.hs
+++ b/Text/XML/Pugi/Foreign/Node.hs
@@ -1,14 +1,18 @@
 {-# LANGUAGE ForeignFunctionInterface #-}
-{-# LANGUAGE ImpredicativeTypes #-}
-{-# LANGUAGE Rank2Types #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE ImpredicativeTypes #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE CPP #-}
+
 module Text.XML.Pugi.Foreign.Node where
 
+#if !MIN_VERSION_base(4,8,0)
 import Control.Applicative
+#endif
 import Control.Monad
 import Control.Exception
 
@@ -43,18 +47,18 @@
 foreign import ccall node_name  :: Ptr n -> IO CString
 foreign import ccall node_value :: Ptr n -> IO CString
 
-foreign import ccall node_parent           :: Ptr n -> IO (Ptr (Node_ Unknown a))
-foreign import ccall node_first_child      :: Ptr n -> IO (Ptr (Node_ Unknown a))
-foreign import ccall node_last_child       :: Ptr n -> IO (Ptr (Node_ Unknown a))
-foreign import ccall node_next_sibling     :: Ptr n -> IO (Ptr (Node_ Unknown a))
-foreign import ccall node_previous_sibling :: Ptr n -> IO (Ptr (Node_ Unknown a))
+foreign import ccall node_parent           :: Ptr n -> IO (Ptr (Node_ 'Unknown a))
+foreign import ccall node_first_child      :: Ptr n -> IO (Ptr (Node_ 'Unknown a))
+foreign import ccall node_last_child       :: Ptr n -> IO (Ptr (Node_ 'Unknown a))
+foreign import ccall node_next_sibling     :: Ptr n -> IO (Ptr (Node_ 'Unknown a))
+foreign import ccall node_previous_sibling :: Ptr n -> IO (Ptr (Node_ 'Unknown a))
 
-foreign import ccall node_child :: Ptr n -> CString -> IO (Ptr (Node_ Unknown a))
+foreign import ccall node_child :: Ptr n -> CString -> IO (Ptr (Node_ 'Unknown a))
 foreign import ccall node_attribute :: Ptr n -> CString -> IO (Ptr Attr)
-foreign import ccall node_next_sibling_by_name :: Ptr n -> CString -> IO (Ptr (Node_ Unknown a))
-foreign import ccall node_previous_sibling_by_name :: Ptr n -> CString -> IO (Ptr (Node_ Unknown a))
-foreign import ccall node_find_child_by_name_and_attribute :: Ptr n -> CString -> CString -> CString -> IO (Ptr (Node_ Unknown a))
-foreign import ccall node_find_child_by_attribute :: Ptr n -> CString -> CString -> IO (Ptr (Node_ Unknown a))
+foreign import ccall node_next_sibling_by_name :: Ptr n -> CString -> IO (Ptr (Node_ 'Unknown a))
+foreign import ccall node_previous_sibling_by_name :: Ptr n -> CString -> IO (Ptr (Node_ 'Unknown a))
+foreign import ccall node_find_child_by_name_and_attribute :: Ptr n -> CString -> CString -> CString -> IO (Ptr (Node_ 'Unknown a))
+foreign import ccall node_find_child_by_attribute :: Ptr n -> CString -> CString -> IO (Ptr (Node_ 'Unknown a))
 
 foreign import ccall node_child_value :: Ptr n -> IO CString
 foreign import ccall node_child_value_by_name :: Ptr n -> CString -> IO CString
@@ -74,8 +78,8 @@
 foreign import ccall find_child     :: Ptr n -> FunPtr NodePred -> IO (Ptr (Node_ k m))
 foreign import ccall find_node      :: Ptr n -> FunPtr NodePred -> IO (Ptr (Node_ k m))
 
-type BeginEnd m = Ptr (Node_ Unknown m) -> IO CInt
-type ForEach  m = CInt -> Ptr (Node_ Unknown m) -> IO CInt
+type BeginEnd m = Ptr (Node_ 'Unknown m) -> IO CInt
+type ForEach  m = CInt -> Ptr (Node_ 'Unknown m) -> IO CInt
 foreign import ccall "wrapper" wrap_begin_end :: BeginEnd m -> IO (FunPtr (BeginEnd m))
 foreign import ccall "wrapper" wrap_for_each  :: ForEach  m -> IO (FunPtr (ForEach  m))
 
@@ -85,9 +89,9 @@
 
 foreign import ccall node_path :: Ptr n -> CChar -> IO CString -- must be free
 
-foreign import ccall node_first_element_by_path :: Ptr n -> CString -> CChar -> IO (Ptr (Node_ Unknown a))
+foreign import ccall node_first_element_by_path :: Ptr n -> CString -> CChar -> IO (Ptr (Node_ 'Unknown a))
 
-foreign import ccall node_root :: Ptr n -> IO (Ptr (Node_ Unknown a))
+foreign import ccall node_root :: Ptr n -> IO (Ptr (Node_ 'Unknown a))
 
 foreign import ccall set_name  :: Ptr n -> CString -> IO CInt
 foreign import ccall set_value :: Ptr n -> CString -> IO CInt
@@ -149,18 +153,18 @@
     getValue :: n k m -> IO S.ByteString
     getValue n = withNode n $ node_value >=> S.packCString
 
-    parent :: n k m -> IO (Maybe (Node_ Unknown m))
+    parent :: n k m -> IO (Maybe (Node_ 'Unknown m))
     parent n = nodeCommon n node_parent
-    firstChild :: n k m -> IO (Maybe (Node_ Unknown m))
+    firstChild :: n k m -> IO (Maybe (Node_ 'Unknown m))
     firstChild n = nodeCommon n node_first_child
-    lastChild :: n k m -> IO (Maybe (Node_ Unknown m))
+    lastChild :: n k m -> IO (Maybe (Node_ 'Unknown m))
     lastChild n = nodeCommon n node_last_child
-    nextSibling :: n k m -> IO (Maybe (Node_ Unknown m))
+    nextSibling :: n k m -> IO (Maybe (Node_ 'Unknown m))
     nextSibling n = nodeCommon n node_next_sibling
-    prevSibling :: n k m -> IO (Maybe (Node_ Unknown m))
+    prevSibling :: n k m -> IO (Maybe (Node_ 'Unknown m))
     prevSibling n = nodeCommon n node_previous_sibling
 
-    child :: S.ByteString -> n k m -> IO (Maybe (Node_ Unknown m))
+    child :: S.ByteString -> n k m -> IO (Maybe (Node_ 'Unknown m))
     child nm n = nodeCommon n $ \p -> S.useAsCString nm $ node_child p
 
     attribute :: S.ByteString -> n k m -> IO (Maybe S.ByteString)
@@ -170,22 +174,22 @@
         then return Nothing
         else fmap Just $ attr_value attr >>= S.packCString
 
-    nextSiblingByName :: S.ByteString -> n k m -> IO (Maybe (Node_ Unknown m))
+    nextSiblingByName :: S.ByteString -> n k m -> IO (Maybe (Node_ 'Unknown m))
     nextSiblingByName nm n = nodeCommon n $ \p -> S.useAsCString nm $ node_next_sibling_by_name p
-    prevSiblingByName :: S.ByteString -> n k m -> IO (Maybe (Node_ Unknown m))
+    prevSiblingByName :: S.ByteString -> n k m -> IO (Maybe (Node_ 'Unknown m))
     prevSiblingByName nm n = nodeCommon n $ \p -> S.useAsCString nm $ node_previous_sibling_by_name p
 
     findChildByNameAndAttr :: S.ByteString -- ^ node name
                            -> S.ByteString -- ^ attribute name
                            -> S.ByteString -- ^ attribute value
-                           -> n k m -> IO (Maybe (Node_ Unknown m))
+                           -> n k m -> IO (Maybe (Node_ 'Unknown m))
     findChildByNameAndAttr nn an av n = nodeCommon n $ \p ->
         S.useAsCString nn $ \nn' -> S.useAsCString an $ \an' -> S.useAsCString av $ \av' ->
         node_find_child_by_name_and_attribute p nn' an' av'
 
     findChildByAttr :: S.ByteString -- ^ attribute name
                     -> S.ByteString -- ^ attribute value
-                    -> n k m -> IO (Maybe (Node_ Unknown m))
+                    -> n k m -> IO (Maybe (Node_ 'Unknown m))
     findChildByAttr an av n = nodeCommon n $ \p ->
         S.useAsCString an $ \an' -> S.useAsCString av $ \av' ->
         node_find_child_by_attribute p an' av'
@@ -207,13 +211,13 @@
             then return Nothing
             else fmap Just $ (,) <$> (S.packCString =<< attr_name attr) <*> (S.packCString =<< attr_value attr)
 
-    findChild :: (Node -> Bool) -> n k m -> IO (Maybe (Node_ Unknown m))
+    findChild :: (Node -> Bool) -> n k m -> IO (Maybe (Node_ 'Unknown m))
     findChild f nd = nodeCommon nd $ \n -> with_node_pred f $ find_child n
 
-    findNode :: (Node -> Bool) -> n k m -> IO (Maybe (Node_ Unknown m))
+    findNode :: (Node -> Bool) -> n k m -> IO (Maybe (Node_ 'Unknown m))
     findNode f nd = nodeCommon nd $ \n -> with_node_pred f $ find_node n
 
-    mapSiblingM_ :: (Node_ Unknown m -> IO b) -> n k m -> IO ()
+    mapSiblingM_ :: (Node_ 'Unknown m -> IO b) -> n k m -> IO ()
     mapSiblingM_ func n = withNode n $ \p -> do
         let f e = () <$ (func . Node =<< newForeignPtr_ e)
         bracket (wrap_node_mapper f) freeHaskellFunPtr $ node_map_sibling p
@@ -230,53 +234,53 @@
     path del node = withNode node $ \p ->
         bracket (node_path p (fromIntegral $ c2w del)) free $ S.packCString
 
-    firstElementByPath :: Char -> S.ByteString -> n k m -> IO (Maybe (Node_ Unknown m))
+    firstElementByPath :: Char -> S.ByteString -> n k m -> IO (Maybe (Node_ 'Unknown m))
     firstElementByPath del path_ node = nodeCommon node $ \p ->
         S.useAsCString path_ $ \d -> node_first_element_by_path p d (fromIntegral $ c2w del)
 
-    root :: n k m -> IO (Maybe (Node_ Unknown m))
+    root :: n k m -> IO (Maybe (Node_ 'Unknown m))
     root node = nodeCommon node $ node_root
 
-    setName :: S.ByteString -> n k Mutable -> IO Bool
+    setName :: S.ByteString -> n k 'Mutable -> IO Bool
     setName n node = withNode node $ \p -> S.useAsCString n $ \q ->
         toBool <$> set_name p q
-    setValue :: S.ByteString -> n k Mutable -> IO Bool
+    setValue :: S.ByteString -> n k 'Mutable -> IO Bool
     setValue n node = withNode node $ \p -> S.useAsCString n $ \q ->
         toBool <$> set_value p q
 
-    appendAttr :: S.ByteString -> S.ByteString -> n k Mutable -> IO Bool
+    appendAttr :: S.ByteString -> S.ByteString -> n k 'Mutable -> IO Bool
     appendAttr k v n = withNode n $ \np -> S.useAsCString k $ \kp -> S.useAsCString v $ \vp ->
         toBool <$> append_attribute np kp vp
-    prependAttr :: S.ByteString -> S.ByteString -> n k Mutable -> IO Bool
+    prependAttr :: S.ByteString -> S.ByteString -> n k 'Mutable -> IO Bool
     prependAttr k v n = withNode n $ \np -> S.useAsCString k $ \kp -> S.useAsCString v $ \vp ->
         toBool <$> prepend_attribute np kp vp
 
-    setAttr :: S.ByteString -> S.ByteString -> n k Mutable -> IO Bool
+    setAttr :: S.ByteString -> S.ByteString -> n k 'Mutable -> IO Bool
     setAttr k v n = withNode n $ \np -> S.useAsCString k $ \kp ->
         bracket (node_attribute np kp) delete_attr $ \attr ->
             if attr == nullPtr
                 then return False
                 else toBool <$> S.useAsCString v (attr_set_value attr)
 
-    appendChild :: NodeType -> n k Mutable -> IO (Maybe (Node_ l Mutable))
+    appendChild :: NodeType -> n k 'Mutable -> IO (Maybe (Node_ l 'Mutable))
     appendChild t n = nodeCommon n $ \p -> append_child p t
-    prependChild :: NodeType -> n k Mutable -> IO (Maybe (Node_ l Mutable))
+    prependChild :: NodeType -> n k 'Mutable -> IO (Maybe (Node_ l 'Mutable))
     prependChild t n = nodeCommon n $ \p -> prepend_child p t
 
-    appendCopy :: Node_ k a -> n l Mutable -> IO (Maybe (Node_ k Mutable))
+    appendCopy :: Node_ k a -> n l 'Mutable -> IO (Maybe (Node_ k 'Mutable))
     appendCopy t n = nodeCommon n $ \p -> withNode t (append_copy p)
-    prependCopy :: Node_ k a -> n l Mutable -> IO (Maybe (Node_ k Mutable))
+    prependCopy :: Node_ k a -> n l 'Mutable -> IO (Maybe (Node_ k 'Mutable))
     prependCopy t n = nodeCommon n $ \p -> withNode t (prepend_copy p)
 
-    removeAttr :: S.ByteString -> n k Mutable -> IO Bool
+    removeAttr :: S.ByteString -> n k 'Mutable -> IO Bool
     removeAttr a n = withNode n $ \p -> S.useAsCString a $ \c ->
         toBool <$> remove_attribute p c
 
-    removeChild :: Node_ k a -> n l Mutable -> IO Bool
+    removeChild :: Node_ k a -> n l 'Mutable -> IO Bool
     removeChild c n = withNode n $ \p -> withNode c $ \q ->
         toBool <$> remove_child p q
 
-    appendBuffer :: ParseConfig -> S.ByteString -> n k Mutable -> IO Bool
+    appendBuffer :: ParseConfig -> S.ByteString -> n k 'Mutable -> IO Bool
     appendBuffer (ParseConfig (ParseFlags flags) enc) str node = fmap toBool $
         withNode node $ \n -> S.unsafeUseAsCStringLen str $ \(c,l) ->
         bracket (append_buffer n c (fromIntegral l) flags enc) delete_parse_result
@@ -304,7 +308,7 @@
 
 -- xpath_node
 foreign import ccall delete_xpath_node :: Ptr XNode -> IO ()
-foreign import ccall xpath_node_node :: Ptr XNode -> IO (Ptr (Node_ Unknown m))
+foreign import ccall xpath_node_node :: Ptr XNode -> IO (Ptr (Node_ 'Unknown m))
 foreign import ccall xpath_node_attribute :: Ptr XNode -> IO (Ptr Attr)
 
 foreign import ccall "&delete_xpath_node_set" finalizerXpathNodeSet :: FinalizerPtr (NodeSet m)
@@ -321,7 +325,7 @@
         else Left . Node <$> newForeignPtr finalizerNode n
 
 
-mapSiblingM :: NodeLike n => (Node_ Unknown m -> IO a) -> n l m -> IO [a]
+mapSiblingM :: NodeLike n => (Node_ 'Unknown m -> IO a) -> n l m -> IO [a]
 mapSiblingM func node = do
     ref <- newIORef id
     mapSiblingM_ (\n -> func n >>= \a -> modifyIORef ref (\f -> f . (a:))) node
diff --git a/Text/XML/Pugi/Foreign/Types.hs b/Text/XML/Pugi/Foreign/Types.hs
--- a/Text/XML/Pugi/Foreign/Types.hs
+++ b/Text/XML/Pugi/Foreign/Types.hs
@@ -20,12 +20,12 @@
               | Unknown
 
 newtype Document_ (k :: NodeKind) (m :: MutableFlag) = Document (ForeignPtr (Document_ k m))
-type Document = Document_ Unknown Immutable
-type MutableDocument = Document_ Unknown Mutable
+type Document = Document_ 'Unknown 'Immutable
+type MutableDocument = Document_ 'Unknown 'Mutable
 
 newtype Node_ (k :: NodeKind) (m :: MutableFlag) = Node (ForeignPtr (Node_ k m))
-type Node = Node_ Unknown Immutable
-type MutableNode k = Node_ k Mutable
+type Node = Node_ 'Unknown 'Immutable
+type MutableNode k = Node_ k 'Mutable
 
 newtype ParseResult = ParseResult (Ptr ParseResult)
 
@@ -38,4 +38,4 @@
 data Attr
 data XNode
 type Attribute = (S.ByteString, S.ByteString)
-type XPathNode m = Either (Node_ Unknown m) Attribute
+type XPathNode m = Either (Node_ 'Unknown m) Attribute
diff --git a/Text/XML/Pugi/Foreign/XPath.hs b/Text/XML/Pugi/Foreign/XPath.hs
--- a/Text/XML/Pugi/Foreign/XPath.hs
+++ b/Text/XML/Pugi/Foreign/XPath.hs
@@ -7,13 +7,16 @@
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE CPP #-}
 
 module Text.XML.Pugi.Foreign.XPath where
 
 import Language.Haskell.TH
 import Language.Haskell.TH.Quote
 
+#if !MIN_VERSION_base(4,8,0)
 import Control.Applicative
+#endif
 import Control.Exception
 
 import Foreign.ForeignPtr
diff --git a/Text/XML/Pugi/Foreign/XPath/Node.hs b/Text/XML/Pugi/Foreign/XPath/Node.hs
--- a/Text/XML/Pugi/Foreign/XPath/Node.hs
+++ b/Text/XML/Pugi/Foreign/XPath/Node.hs
@@ -1,7 +1,11 @@
 {-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE CPP #-}
+
 module Text.XML.Pugi.Foreign.XPath.Node where
 
+#if !MIN_VERSION_base(4,8,0)
 import Control.Applicative
+#endif
 import Control.Exception
 
 import Foreign.ForeignPtr
diff --git a/Text/XML/Pugi/Mutable.hs b/Text/XML/Pugi/Mutable.hs
--- a/Text/XML/Pugi/Mutable.hs
+++ b/Text/XML/Pugi/Mutable.hs
@@ -89,128 +89,128 @@
     return d
 
 appendElement :: (HasChildren k, MutableNodeLike n)
-              => S.ByteString -> n k Mutable -> Modify (MutableNode Element)
+              => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Element)
 appendElement n e = appendChild nodeTypeElement e >>= \r -> setName n r >> return r
 
 prependElement :: (HasChildren k, MutableNodeLike n)
-               => S.ByteString -> n k Mutable -> Modify (MutableNode Element)
+               => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Element)
 prependElement n e = prependChild nodeTypeElement e >>= \r -> setName n r >> return r
 
 appendDeclaration :: (HasChildren k, MutableNodeLike n)
-                  => S.ByteString -> n k Mutable -> Modify (MutableNode Declaration)
+                  => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Declaration)
 appendDeclaration n e = appendChild nodeTypeDeclaration e >>= \r -> setName n r >> return r
 
 prependDeclaration :: (HasChildren k, MutableNodeLike n)
-                   => S.ByteString -> n k Mutable -> Modify (MutableNode Declaration)
+                   => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Declaration)
 prependDeclaration n e = prependChild nodeTypeDeclaration e >>= \r -> setName n r >> return r
 
 appendPCData :: (HasChildren k, MutableNodeLike n)
-             => S.ByteString -> n k Mutable -> Modify (MutableNode PCData)
+             => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'PCData)
 appendPCData n e = appendChild nodeTypePCData e >>= \r -> setValue n r >> return r
 
 prependPCData :: (HasChildren k, MutableNodeLike n)
-              => S.ByteString -> n k Mutable -> Modify (MutableNode PCData)
+              => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'PCData)
 prependPCData n e = prependChild nodeTypePCData e >>= \r -> setValue n r >> return r
 
 appendCData :: (HasChildren k, MutableNodeLike n)
-            => S.ByteString -> n k Mutable -> Modify (MutableNode CData)
+            => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'CData)
 appendCData n e = appendChild nodeTypeCData e >>= \r -> setValue n r >> return r
 
 prependCData :: (HasChildren k, MutableNodeLike n)
-             => S.ByteString -> n k Mutable -> Modify (MutableNode CData)
+             => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'CData)
 prependCData n e = prependChild nodeTypeCData e >>= \r -> setValue n r >> return r
 
 appendComment :: (HasChildren k, MutableNodeLike n)
-              => S.ByteString -> n k Mutable -> Modify (MutableNode Comment)
+              => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Comment)
 appendComment n e = appendChild nodeTypeComment e >>= \r -> setValue n r >> return r
 
 prependComment :: (HasChildren k, MutableNodeLike n)
-               => S.ByteString -> n k Mutable -> Modify (MutableNode Comment)
+               => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Comment)
 prependComment n e = prependChild nodeTypeComment e >>= \r -> setValue n r >> return r
 
 appendDoctype :: (HasChildren k, MutableNodeLike n)
-              => S.ByteString -> n k Mutable -> Modify (MutableNode Doctype)
+              => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Doctype)
 appendDoctype n e = appendChild nodeTypeDoctype e >>= \r -> setValue n r >> return r
 
 prependDoctype :: (HasChildren k, MutableNodeLike n)
-               => S.ByteString -> n k Mutable -> Modify (MutableNode Doctype)
+               => S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Doctype)
 prependDoctype n e = prependChild nodeTypeDoctype e >>= \r -> setValue n r >> return r
 
 appendPi :: (HasChildren k, MutableNodeLike n)
-         => S.ByteString -> S.ByteString -> n k Mutable -> Modify (MutableNode Pi)
+         => S.ByteString -> S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Pi)
 appendPi n v e = appendChild nodeTypePi e >>= \r -> setName n r >> setValue v r >> return r
 
 prependPi :: (HasChildren k, MutableNodeLike n)
-          => S.ByteString -> S.ByteString -> n k Mutable -> Modify (MutableNode Pi)
+          => S.ByteString -> S.ByteString -> n k 'Mutable -> Modify (MutableNode 'Pi)
 prependPi n v e = prependChild nodeTypePi e >>= \r -> setName n r >> setValue v r >> return r
 
 class MutableNodeLike (n :: NodeKind -> MutableFlag -> *) where
-    asNode                 :: n k Mutable -> Modify (Node_ k Mutable)
-    nodeEqual              :: n k Mutable -> n l o -> Modify Bool
-    forgetNodeKind         :: n k Mutable -> n Unknown Mutable
+    asNode                 :: n k 'Mutable -> Modify (Node_ k 'Mutable)
+    nodeEqual              :: n k 'Mutable -> n l o -> Modify Bool
+    forgetNodeKind         :: n k 'Mutable -> n 'Unknown 'Mutable
     forgetNodeKind = unsafeCoerce
     {-# INLINE forgetNodeKind #-}
-    prettyNode             :: D.PrettyConfig -> Int -> n k Mutable -> Modify L.ByteString
-    hashValue              :: n k Mutable -> Modify CSize
-    nodeType               :: n k Mutable -> Modify NodeType
-    getName                :: HasName  k => n k Mutable -> Modify S.ByteString
-    getValue               :: HasValue k => n k Mutable -> Modify S.ByteString
-    parent                 :: n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    firstChild             :: HasChildren k => n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    lastChild              :: HasChildren k => n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    nextSibling            :: n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    prevSibling            :: n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    child                  :: HasChildren  k => S.ByteString -> n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    attribute              :: HasAttribute k => S.ByteString -> n k Mutable -> Modify (Maybe S.ByteString)
-    nextSiblingByName      :: S.ByteString -> n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    prevSiblingByName      :: S.ByteString -> n k Mutable -> Modify (Maybe (MutableNode Unknown))
+    prettyNode             :: D.PrettyConfig -> Int -> n k 'Mutable -> Modify L.ByteString
+    hashValue              :: n k 'Mutable -> Modify CSize
+    nodeType               :: n k 'Mutable -> Modify NodeType
+    getName                :: HasName  k => n k 'Mutable -> Modify S.ByteString
+    getValue               :: HasValue k => n k 'Mutable -> Modify S.ByteString
+    parent                 :: n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    firstChild             :: HasChildren k => n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    lastChild              :: HasChildren k => n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    nextSibling            :: n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    prevSibling            :: n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    child                  :: HasChildren  k => S.ByteString -> n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    attribute              :: HasAttribute k => S.ByteString -> n k 'Mutable -> Modify (Maybe S.ByteString)
+    nextSiblingByName      :: S.ByteString -> n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    prevSiblingByName      :: S.ByteString -> n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
     findChildByNameAndAttr :: HasChildren k
                            => S.ByteString -- ^ node name
                            -> S.ByteString -- ^ attribute name
                            -> S.ByteString -- ^ attribute value
-                           -> n k Mutable -> Modify (Maybe (MutableNode Unknown))
+                           -> n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
     findChildByAttr        :: HasChildren k
                            => S.ByteString -- ^ attribute name
                            -> S.ByteString -- ^ attribute value
-                           -> n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    childValue             :: HasChildren k => n k Mutable -> Modify S.ByteString
-    childValueByName       :: HasChildren k => S.ByteString -> n k Mutable -> Modify S.ByteString
-    text                   :: n k Mutable -> Modify S.ByteString
+                           -> n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    childValue             :: HasChildren k => n k 'Mutable -> Modify S.ByteString
+    childValueByName       :: HasChildren k => S.ByteString -> n k 'Mutable -> Modify S.ByteString
+    text                   :: n k 'Mutable -> Modify S.ByteString
 
     -- | find attribute by predicate. since v0.2.0.
-    findAttribute          :: (S.ByteString -> S.ByteString -> Bool) -> n k Mutable -> Modify (Maybe Attribute)
+    findAttribute          :: (S.ByteString -> S.ByteString -> Bool) -> n k 'Mutable -> Modify (Maybe Attribute)
 
     -- | find child by predicate. since v0.2.0.
-    findChild              :: (Node -> Bool) -> n k Mutable -> Modify (Maybe (MutableNode Unknown))
+    findChild              :: (Node -> Bool) -> n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
 
     -- | find node by predicate. since v0.2.0.
-    findNode               :: (Node -> Bool) -> n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    path                   :: Char -> n k Mutable -> Modify S.ByteString
-    firstElementByPath     :: Char -> S.ByteString -> n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    root                   :: n k Mutable -> Modify (Maybe (MutableNode Unknown))
-    evaluate               :: X.EvalXPath r => XPath r -> n k Mutable -> Modify (X.XPathResult r Mutable)
-    selectSingleNode       :: XPath NodeSet -> n k Mutable -> Modify (XPathNode Mutable)
-    selectNodes            :: XPath NodeSet -> n k Mutable -> Modify (NodeSet Mutable)
+    findNode               :: (Node -> Bool) -> n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    path                   :: Char -> n k 'Mutable -> Modify S.ByteString
+    firstElementByPath     :: Char -> S.ByteString -> n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    root                   :: n k 'Mutable -> Modify (Maybe (MutableNode 'Unknown))
+    evaluate               :: X.EvalXPath r => XPath r -> n k 'Mutable -> Modify (X.XPathResult r 'Mutable)
+    selectSingleNode       :: XPath NodeSet -> n k 'Mutable -> Modify (XPathNode 'Mutable)
+    selectNodes            :: XPath NodeSet -> n k 'Mutable -> Modify (NodeSet 'Mutable)
 
-    setName        :: HasName      k => S.ByteString -> n k Mutable -> Modify ()
-    setValue       :: HasValue     k => S.ByteString -> n k Mutable -> Modify ()
-    appendAttr     :: HasAttribute k => S.ByteString -> S.ByteString -> n k Mutable -> Modify ()
-    prependAttr    :: HasAttribute k => S.ByteString -> S.ByteString -> n k Mutable -> Modify ()
-    setAttr        :: HasAttribute k => S.ByteString -> S.ByteString -> n k Mutable -> Modify ()
+    setName        :: HasName      k => S.ByteString -> n k 'Mutable -> Modify ()
+    setValue       :: HasValue     k => S.ByteString -> n k 'Mutable -> Modify ()
+    appendAttr     :: HasAttribute k => S.ByteString -> S.ByteString -> n k 'Mutable -> Modify ()
+    prependAttr    :: HasAttribute k => S.ByteString -> S.ByteString -> n k 'Mutable -> Modify ()
+    setAttr        :: HasAttribute k => S.ByteString -> S.ByteString -> n k 'Mutable -> Modify ()
     -- | generic appendChild method. Recommend to use 'appendElement' etc...
-    appendChild    :: HasChildren  k => NodeType -> n k Mutable -> Modify (MutableNode l)
+    appendChild    :: HasChildren  k => NodeType -> n k 'Mutable -> Modify (MutableNode l)
     -- | generic prependChild method. Recommend to use 'prependElement' etc...
-    prependChild   :: HasChildren  k => NodeType -> n k Mutable -> Modify (MutableNode l)
-    appendCopy     :: HasChildren  k => Node_ k a -> n l Mutable -> Modify (MutableNode k)
-    prependCopy    :: HasChildren  k => Node_ k a -> n l Mutable -> Modify (MutableNode k)
-    removeAttr     :: HasAttribute k => S.ByteString -> n k Mutable -> Modify ()
-    removeChild    :: HasChildren  k => Node_ k a -> n l Mutable -> Modify ()
-    appendFlagment :: HasChildren  k => D.ParseConfig -> S.ByteString -> n k Mutable -> Modify ()
+    prependChild   :: HasChildren  k => NodeType -> n k 'Mutable -> Modify (MutableNode l)
+    appendCopy     :: HasChildren  k => Node_ k a -> n l 'Mutable -> Modify (MutableNode k)
+    prependCopy    :: HasChildren  k => Node_ k a -> n l 'Mutable -> Modify (MutableNode k)
+    removeAttr     :: HasAttribute k => S.ByteString -> n k 'Mutable -> Modify ()
+    removeChild    :: HasChildren  k => Node_ k a -> n l 'Mutable -> Modify ()
+    appendFlagment :: HasChildren  k => D.ParseConfig -> S.ByteString -> n k 'Mutable -> Modify ()
 
-    mapSiblingM  :: (MutableNode Unknown -> Modify a) -> n k Mutable -> Modify [a]
-    mapSiblingM_ :: (MutableNode Unknown -> Modify a) -> n k Mutable -> Modify ()
+    mapSiblingM  :: (MutableNode 'Unknown -> Modify a) -> n k 'Mutable -> Modify [a]
+    mapSiblingM_ :: (MutableNode 'Unknown -> Modify a) -> n k 'Mutable -> Modify ()
 
-appendAttrs :: (MutableNodeLike n, HasAttribute k) => [Attribute] ->  n k Mutable -> Modify ()
+appendAttrs :: (MutableNodeLike n, HasAttribute k) => [Attribute] ->  n k 'Mutable -> Modify ()
 appendAttrs as n = mapM_ (\(k,v) -> appendAttr k v n) as
 
 instance MutableNodeLike Node_ where
@@ -312,56 +312,56 @@
     mapSiblingM_ f = Modify . fmap sequence_ . N.mapSiblingM (runModify . f)
 
 setOrAppendAttr :: (HasAttribute k, MutableNodeLike n)
-                => S.ByteString -> S.ByteString -> n k Mutable -> Modify ()
+                => S.ByteString -> S.ByteString -> n k 'Mutable -> Modify ()
 setOrAppendAttr k v n = setAttr k v n <|> appendAttr k v n
 
-isetName :: N.NodeLike n => S.ByteString -> n k Mutable -> Modify ()
+isetName :: N.NodeLike n => S.ByteString -> n k 'Mutable -> Modify ()
 isetName n nd = mLiftIO (N.setName n nd) >>= 
     flip unless (fail $ "setName: " ++ show n)
 
-isetValue :: N.NodeLike n => S.ByteString -> n k Mutable -> Modify ()
+isetValue :: N.NodeLike n => S.ByteString -> n k 'Mutable -> Modify ()
 isetValue n nd = mLiftIO (N.setValue n nd) >>=
     flip unless (fail $ "setValue: " ++ show n)
 
 iappendAttr :: N.NodeLike n => S.ByteString -> S.ByteString
-            -> n k Mutable -> Modify ()
+            -> n k 'Mutable -> Modify ()
 iappendAttr k v n = mLiftIO (N.appendAttr k v n) >>=
     flip unless (fail $ "appendAttr: " ++ show k ++ " = " ++ show v)
 
 iprependAttr :: N.NodeLike n => S.ByteString -> S.ByteString
-             -> n k Mutable -> Modify ()
+             -> n k 'Mutable -> Modify ()
 iprependAttr k v n = mLiftIO (N.prependAttr k v n) >>=
     flip unless (fail $ "appendAttr: " ++ show k ++ " = " ++ show v)
 
 isetAttr :: N.NodeLike n => S.ByteString -> S.ByteString
-         -> n k Mutable -> Modify ()
+         -> n k 'Mutable -> Modify ()
 isetAttr k v n = mLiftIO (N.setAttr k v n) >>=
     flip unless (fail $ "setAttr: " ++ show k ++ " = " ++ show v)
 
-iappendChild :: N.NodeLike n => NodeType -> n l Mutable -> Modify (MutableNode k)
+iappendChild :: N.NodeLike n => NodeType -> n l 'Mutable -> Modify (MutableNode k)
 iappendChild t n = mLiftIO (N.appendChild t n) >>=
     maybe (fail $ "appendChild: " ++ show t) return
 
-iprependChild :: N.NodeLike n => NodeType -> n l Mutable -> Modify (MutableNode k)
+iprependChild :: N.NodeLike n => NodeType -> n l 'Mutable -> Modify (MutableNode k)
 iprependChild t n = mLiftIO (N.prependChild t n) >>=
     maybe (fail $ "prependChild: " ++ show t) return
 
-iappendCopy :: N.NodeLike n => Node_ k a -> n l Mutable -> Modify (MutableNode k)
+iappendCopy :: N.NodeLike n => Node_ k a -> n l 'Mutable -> Modify (MutableNode k)
 iappendCopy t n = mLiftIO (N.appendCopy t n) >>=
     maybe (fail "appendCopy") return
 
-iprependCopy :: N.NodeLike n => Node_ k a -> n l Mutable -> Modify (MutableNode k)
+iprependCopy :: N.NodeLike n => Node_ k a -> n l 'Mutable -> Modify (MutableNode k)
 iprependCopy t n = mLiftIO (N.prependCopy t n) >>=
     maybe (fail "prependCopy") return
 
-iremoveAttr :: N.NodeLike n => S.ByteString -> n k Mutable -> Modify ()
+iremoveAttr :: N.NodeLike n => S.ByteString -> n k 'Mutable -> Modify ()
 iremoveAttr n nd = mLiftIO (N.removeAttr n nd) >>=
     flip unless (fail $ "removeAttr: " ++ show n)
 
-iremoveChild :: N.NodeLike n => Node_ l a -> n k Mutable -> Modify ()
+iremoveChild :: N.NodeLike n => Node_ l a -> n k 'Mutable -> Modify ()
 iremoveChild n nd = mLiftIO (N.removeChild n nd) >>=
     flip unless (fail "removeChild")
 
-iappendFlagment :: N.NodeLike n => D.ParseConfig -> S.ByteString -> n k Mutable -> Modify ()
+iappendFlagment :: N.NodeLike n => D.ParseConfig -> S.ByteString -> n k 'Mutable -> Modify ()
 iappendFlagment cfg str n = mLiftIO (N.appendBuffer cfg str n) >>=
     flip unless (fail $ "appendFlagment: " ++ show str)
diff --git a/pugixml.cabal b/pugixml.cabal
--- a/pugixml.cabal
+++ b/pugixml.cabal
@@ -1,14 +1,14 @@
 name:                pugixml
-version:             0.3.0
+version:             0.3.1
 synopsis:            pugixml binding.
-description:         pugixml binding. example: <Text-XML-Pugi.html>
+description:         pugixml binding. example: <docs/Text-XML-Pugi.html>
 license:             MIT
 license-file:        LICENSE
 author:              HirotomoMoriwaki<philopon.dependence@gmail.com>
 maintainer:          HirotomoMoriwaki<philopon.dependence@gmail.com>
 Homepage:            https://github.com/philopon/pugixml-hs
 Bug-reports:         https://github.com/philopon/pugixml-hs/issues
-copyright:           (c) 2014 Hirotomo Moriwaki
+copyright:           (c) 2014-2015 Hirotomo Moriwaki
 category:            Text, XML
 build-type:          Simple
 extra-source-files:  pugixml-1.4/pugiconfig.hpp
@@ -28,10 +28,10 @@
                        Text.XML.Pugi.Foreign.Attr
   -- other-modules:       
   -- other-extensions:    
-  build-depends:       base               >=4.6  && <4.8
+  build-depends:       base               >=4.6  && <4.9
                      , bytestring         >=0.10 && <0.11
                      , data-default-class >=0.0  && <0.1
-                     , template-haskell   >=2.8  && <2.10
+                     , template-haskell   >=2.8  && <2.11
   -- hs-source-dirs:      
   c-sources:           pugixml-1.4/pugixml.cpp cbit/wrapper.cc
   include-dirs:        pugixml-1.4
@@ -41,7 +41,7 @@
 
 test-suite test
   main-is:             test.hs
-  build-depends:       base               >=4.6  && <4.8
+  build-depends:       base
                      , bytestring         >=0.10 && <0.11
                      , pugixml
                      , tasty              >=0.10 && <0.11
diff --git a/test/test.hs b/test/test.hs
--- a/test/test.hs
+++ b/test/test.hs
@@ -1,6 +1,9 @@
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE CPP #-}
 
+#if MIN_VERSION_base(4,9,0)
 import Control.Applicative
+#endif
 
 import Test.Tasty
 import Test.Tasty.HUnit