diff --git a/language-webidl.cabal b/language-webidl.cabal
--- a/language-webidl.cabal
+++ b/language-webidl.cabal
@@ -1,5 +1,5 @@
 name:                language-webidl
-version:             0.1.1.1
+version:             0.1.2.0
 synopsis:           Parser and Pretty Printer for WebIDL
 description:
     It is intended to replace the old package
diff --git a/src/Language/WebIDL/AST.hs b/src/Language/WebIDL/AST.hs
--- a/src/Language/WebIDL/AST.hs
+++ b/src/Language/WebIDL/AST.hs
@@ -1,8 +1,13 @@
+{-|
+  Module:      Language.WebIDL.AST
+  Description: Abstract Syntax Tree of WebIDL
+-}
+
 module Language.WebIDL.AST where
 
 import Prelude hiding (Enum)
 
--- Definition
+-- | Definition
 data Definition a = DefInterface (Interface a)
                   | DefPartial (Partial a)
                   | DefDictionary (Dictionary a)
@@ -12,74 +17,82 @@
                   | DefImplementsStatement (ImplementsStatement a)
                   deriving (Show, Eq)
 
--- Interface
+-- | @interface@
 data Interface a = Interface a Ident (Maybe Ident) [InterfaceMember a] deriving (Show, Eq)
 
--- Partial
+-- | Partial Definition
 data Partial a = PartialInterface a Ident [InterfaceMember a]
                | PartialDictionary a Ident [DictionaryMember a]
                deriving (Show, Eq)
 
--- Dictionary
+-- | @dictionary@
 data Dictionary a = Dictionary a Ident (Maybe Ident) [DictionaryMember a] deriving (Show, Eq)
 
--- Exception
+-- | @exception@
 data Exception a = Exception a Ident (Maybe Ident) [ExceptionMember a] deriving (Show, Eq)
 
--- Enum
+-- | @enum@
 data Enum a = Enum a Ident [EnumValue] deriving (Show, Eq)
 
--- Typedef
+-- | @typedef@
 data Typedef a = Typedef a Type Ident deriving (Show, Eq)
 
--- Implements
+-- | @implements@ statement
 data ImplementsStatement a = ImplementsStatement a Ident Ident deriving (Show, Eq)
 
--- Fields
+-- | Member of interface definition
 data InterfaceMember a = IMemConst (Const a)
                        | IMemAttribute (Attribute a)
                        | IMemOperation (Operation a)
                        deriving (Show, Eq)
 
+-- | Member of dictionary
 data DictionaryMember a = DictionaryMember a Type Ident (Maybe Default) deriving (Show, Eq)
 
+-- | Member of exception definition
 data ExceptionMember a = ExConst a (Const a)
                        | ExField a Type Ident
                        deriving (Show, Eq)
 
+-- | Attribute member of interface
 data Attribute a = Attribute a (Maybe Inherit) (Maybe ReadOnly) Type Ident deriving (Show, Eq)
 
+-- | Operation member of interface
 data Operation a = Operation a (Maybe Qualifier) ReturnType (Maybe Ident) [Argument] deriving (Show, Eq)
 
+-- | Argument of operation signature
 data Argument = ArgOptional Type ArgumentName Default
               | ArgNonOpt Type (Maybe Ellipsis) ArgumentName
               deriving (Show, Eq)
 
+-- | Value of a @enum@
 newtype EnumValue = EnumValue String deriving (Show, Eq)
 
+-- | Name of argument
 data ArgumentName = ArgKey ArgumentNameKeyword
                   | ArgIdent Ident
                   deriving (Show, Eq)
-
--- Values
+-- | @const@
 data Const a = Const a ConstType Ident ConstValue deriving (Show, Eq)
 
+-- | @default@ specification
 data Default = DefaultValue ConstValue
              | DefaultString String
              deriving (Show, Eq)
 
+-- | Constant value
 data ConstValue = ConstBooleanLiteral Bool
                 | ConstFloatLiteral Double
                 | ConstInteger Integer
                 | ConstNull
                 deriving (Show, Eq)
 
-
--- Qualifers
+-- | Qualifers
 data Qualifier = QuaStatic
                | QSpecials [Special]
                deriving (Show, Eq)
 
+-- | Special qualifier
 data Special = Getter 
              | Setter 
              | Ccreator 
@@ -87,6 +100,7 @@
              | Legacycaller
              deriving (Show, Eq)
 
+-- | Argument name keyword
 data ArgumentNameKeyword = ArgAttribute    | ArgCallback    | ArgConst        | ArgCreator
                          | ArgDeleter      | ArgDictionary  | ArgEnum         | ArgException
                          | ArgGetter       | ArgImplements  | ArgInherit      | ArgInterface
@@ -94,13 +108,15 @@
                          | ArgStringifier  | ArgTypedef     | ArgUnrestricted
                          deriving (Show, Eq)
 
--- Types
+-- | Types
 data Type = TySingleType SingleType | TyUnionType UnionType TypeSuffix deriving (Show, Eq)
 
+-- | Single type
 data SingleType = STyNonAny NonAnyType
                 | STyAny TypeSuffix
                 deriving (Show, Eq)
 
+-- | Types that is not @any@
 data NonAnyType = TyPrim PrimitiveType TypeSuffix
                 | TyDOMString TypeSuffix
                 | TyIdent Ident TypeSuffix
@@ -109,7 +125,7 @@
                 | TyDate TypeSuffix
                 deriving (Show, Eq)
 
-
+-- | Primitive type
 data PrimitiveType = PrimIntegerType IntegerType
                    | PrimFloatType FloatType
                    | Boolean
@@ -117,43 +133,59 @@
                    | Octet
                    deriving (Show, Eq)
 
+-- | Integer type
 data IntegerType = IntegerType (Maybe Unsigned) IntegerWidth deriving (Show, Eq)
 
+-- | Integer width, @short@, @long@ etc.
 data IntegerWidth = Short | Long Int deriving (Show, Eq)
 
+-- | @unsigned@ modifier
+data Unsigned = Unsigned deriving (Show, Eq)
+
+-- | Suffix of type
 data TypeSuffix = TypeSuffixArray
                 | TypeSuffixNullable
                 | TypeSuffixNone
                 deriving (Show, Eq)
 
+-- | Float type
 data FloatType = TyFloat (Maybe Unrestricted)
                | TyDouble (Maybe Unrestricted)
                deriving (Show, Eq)
 
+-- | Union of several types
 type UnionType = [UnionMemberType]
 
+-- | Union member type
 data UnionMemberType = UnionTy UnionType TypeSuffix 
                      | UnionTyNonAny NonAnyType
                      | UnionTyAny TypeSuffix
                      deriving (Show, Eq)
 
+-- | Return value's type
 data ReturnType = RetType Type
                 | RetVoid
                 deriving (Show, Eq)
 
-
+-- | Constant's type
 data ConstType = ConstPrim PrimitiveType (Maybe Null)
                | ConstIdent Ident (Maybe Null)
                deriving (Show, Eq)
 
--- Markers
+-- | @null@ keyword
+data Null = Null deriving (Show, Eq)
 
+-- | @ellipsis@ marker
 data Ellipsis = Ellipsis deriving (Show, Eq)
+
+-- | @readonly@ marker
 data ReadOnly = ReadOnly deriving (Show, Eq)
+
+-- | @inherit@ marker
 data Inherit = Inherit deriving (Show, Eq)
+
+-- | @unrestricted@ marker
 data Unrestricted = Unrestricted deriving (Show, Eq)
-data Null = Null deriving (Show, Eq)
-data Unsigned = Unsigned deriving (Show, Eq)
 
--- Ident
+-- | Identifier
 newtype Ident = Ident String deriving (Show, Eq, Ord)
diff --git a/src/Language/WebIDL/PPrint.hs b/src/Language/WebIDL/PPrint.hs
--- a/src/Language/WebIDL/PPrint.hs
+++ b/src/Language/WebIDL/PPrint.hs
@@ -1,9 +1,17 @@
-module Language.WebIDL.PPrint where
+{-|
+  Module:      Language.WebIDL.PPrint
+  Description: Pretty printer of WebIDL AST
+-}
 
+module Language.WebIDL.PPrint (
+  printDef
+) where
+
 import Language.WebIDL.AST
 import Prelude hiding (Enum)
 import Text.PrettyPrint.Leijen
 
+-- | print definition
 printDef :: Definition a -> String
 printDef = show . pretty
 
@@ -132,7 +140,7 @@
 
 instance Pretty (Operation a) where
     pretty (Operation _ mQ retty mIdent args) =
-        pretty mQ <> pretty retty <+> prettyMaybe mIdent (\e -> pretty e)
+        pretty mQ <> pretty retty <+> prettyMaybe mIdent pretty
                   <> parens (hcat (punctuate (comma <> space) (map pretty args))) <> semi
 
 
diff --git a/src/Language/WebIDL/Parser.hs b/src/Language/WebIDL/Parser.hs
--- a/src/Language/WebIDL/Parser.hs
+++ b/src/Language/WebIDL/Parser.hs
@@ -1,5 +1,12 @@
-module Language.WebIDL.Parser where
+{-|
+  Module:      Language.WebIDL.Parser
+  Description: Parser of WebIDL source
+-}
 
+module Language.WebIDL.Parser (
+  Tag(..), parseIDL
+) where
+
 import Language.WebIDL.AST
 import Prelude hiding (Enum)
 import Text.ParserCombinators.Parsec
@@ -12,16 +19,17 @@
   _comments :: [String]
 }
 
-data Tagging = Tagging {
+-- | Tag of source
+data Tag = Tag {
   _comment :: [String],
   _sourcePos :: SourcePos
 }
 
-instance Eq Tagging where
+instance Eq Tag where
   (==) _ _ = True
 
-instance Show Tagging where
-    show (Tagging comments pos) =
+instance Show Tag where
+    show (Tag comments pos) =
       let line = if length comments > 0 then take 5 (head comments) ++ "..., " else ""
       in  "(" ++ line ++ show (sourceLine pos) ++ ")"
 
@@ -33,10 +41,11 @@
 testParse :: MyParser a -> String -> Either ParseError a
 testParse p = runParser p initState "webidl"
 
-parseIDL :: String -> Either ParseError [Definition Tagging]
+-- | parse IDL source
+parseIDL :: String -> Either ParseError [Definition Tag]
 parseIDL = testParse (pSpaces *> many1 (pDef <* pSpaces))
 
-pDef :: MyParser (Definition Tagging)
+pDef :: MyParser (Definition Tag)
 pDef = DefInterface <$> (pExtAttrs *> pInterface)
    <|> DefPartial <$> pPartial
    <|> DefDictionary <$> pDictionary
@@ -50,7 +59,7 @@
 pExtAttrs = pSpaces *> void (char '[' *> (manyTill anyChar (try (char ']')))) <* pSpaces
         <|> pSpaces
 
-pPartial :: MyParser (Partial Tagging)
+pPartial :: MyParser (Partial Tag)
 pPartial = string "partial" *> pSpaces *> p
   where
     p =   PartialInterface <$> getTag <*> (string "interface" *> pSpaces *> pIdent)
@@ -58,29 +67,29 @@
       <|> PartialDictionary <$> getTag <*> (string "dictionary" *> pSpaces *> pIdent)
                                <*> braces (many pDictionaryMember) <* semi
 
-pDictionary :: MyParser (Dictionary Tagging)
+pDictionary :: MyParser (Dictionary Tag)
 pDictionary = Dictionary <$> getTag <*> (string "dictionary" *> pSpaces *> pIdent)
                          <*> pInheritance <*> braces (many pDictionaryMember) <* semi
 
-pInterface :: MyParser (Interface Tagging)
+pInterface :: MyParser (Interface Tag)
 pInterface = Interface <$> getTag <*> (string "interface" *> pSpaces *> pIdent)
                           <*> pInheritance <*> braces (pSpaces *> many (pInterfaceMember <* pSpaces)) <* semi
 
-pException :: MyParser (Exception Tagging)
+pException :: MyParser (Exception Tag)
 pException = Exception <$> getTag <*> (string "exception" *> pSpaces *> pIdent)
                           <*> pInheritance <*> braces (many pExceptionMember)
 
 pInheritance :: MyParser (Maybe Ident)
 pInheritance = optionMaybe (spaces *> char ':'  *> spaces *> pIdent)
 
-pEnum :: MyParser (Enum Tagging)
+pEnum :: MyParser (Enum Tag)
 pEnum = Enum <$> getTag <*> (string "enum" *> pSpaces *> pIdent) <*> braces pEnumValues <* semi
 
 pEnumValues :: MyParser [EnumValue]
 pEnumValues = sepBy1 (EnumValue <$> stringLit) (char ',')
 
 
-pTypedef :: MyParser (Typedef Tagging)
+pTypedef :: MyParser (Typedef Tag)
 pTypedef = do
   tag <- getTag
   string "typedef"
@@ -91,27 +100,27 @@
   semi
   return (Typedef tag ty ident)
 
-pImplementsStatement :: MyParser (ImplementsStatement Tagging)
+pImplementsStatement :: MyParser (ImplementsStatement Tag)
 pImplementsStatement = ImplementsStatement <$> getTag <*> pIdent <* pSpaces
                                               <*> (string "implements" *> pSpaces *> pIdent <* semi)
 
-pDictionaryMember :: MyParser (DictionaryMember Tagging)
+pDictionaryMember :: MyParser (DictionaryMember Tag)
 pDictionaryMember = DictionaryMember <$> getTag <*> pType <* pSpaces
                                      <*> pIdent <*> optionMaybe (spaces *> pEq *> spaces *> pDefault) <* semi
 
-pExceptionMember :: MyParser (ExceptionMember Tagging)
+pExceptionMember :: MyParser (ExceptionMember Tag)
 pExceptionMember =  ExConst <$> getTag <*> pConst
                 <|> ExField <$> getTag <*> pType <*> pIdent <* semi
 
 pMaybeIdent :: MyParser (Maybe Ident)
 pMaybeIdent = optionMaybe pIdent
 
-pInterfaceMember :: MyParser (InterfaceMember Tagging)
+pInterfaceMember :: MyParser (InterfaceMember Tag)
 pInterfaceMember =  try (IMemConst <$> pConst)
                 <|> try (IMemAttribute <$> pAttribute)
                 <|> IMemOperation <$> (pExtAttrs *> pOperation)
 
-pConst :: MyParser (Const Tagging)
+pConst :: MyParser (Const Tag)
 pConst = Const <$> getTag <*> (string "const" *> pSpaces *> pConstType <* pSpaces)
                <*> (pIdent <* pEq) <*> (pSpaces *> pConstValue <* semi)
 
@@ -119,7 +128,7 @@
 pConstType =  ConstPrim <$> pPrimTy <*> pNull
           <|> ConstIdent <$> pIdent <*> pNull
 
-pAttribute :: MyParser (Attribute Tagging)
+pAttribute :: MyParser (Attribute Tag)
 pAttribute = Attribute <$> getTag <*> pModifier Inherit "inherit"
                        <*> pModifier ReadOnly "readonly"
                        <*> (string "attribute" *> pSpaces *> pType) <*> (pSpaces *> pIdent <* semi)
@@ -127,7 +136,7 @@
 pModifier :: a -> String -> MyParser (Maybe a)
 pModifier m s = optionMaybe (string s *> pSpaces *> return m)
 
-pOperation :: MyParser (Operation Tagging)
+pOperation :: MyParser (Operation Tag)
 pOperation = Operation <$> getTag <*> pQualifier <* spaces
                        <*> pReturnType <* pSpaces
                        <*> pMaybeIdent <* pSpaces
@@ -277,11 +286,9 @@
   comment <- manyTill anyChar (try (string "*/"))
   modifyState (\ps -> ParserState { _comments = _comments ps ++ lines comment})
 
-
-getTag :: MyParser Tagging
+getTag :: MyParser Tag
 getTag = do
   pos <- getPosition
   ParserState comments <- getState
   putState $ ParserState []
-  return $ Tagging comments pos
-
+  return $ Tag comments pos