diff --git a/htoml-megaparsec.cabal b/htoml-megaparsec.cabal
--- a/htoml-megaparsec.cabal
+++ b/htoml-megaparsec.cabal
@@ -1,5 +1,5 @@
-name:                    htoml-megaparsec
-version:                  1.0.1.7
+name:                     htoml-megaparsec
+version:                  1.0.1.8
 synopsis:                 Parser for TOML files
 description:              TOML is an obvious and minimal format for config files.
                           This package provides a TOML parser
diff --git a/src/Text/Toml/Parser.hs b/src/Text/Toml/Parser.hs
--- a/src/Text/Toml/Parser.hs
+++ b/src/Text/Toml/Parser.hs
@@ -35,7 +35,6 @@
 import           Text.Toml.Types
 
 -- Imported last to fix redundancy warning
-import           Debug.Trace
 import           Prelude                hiding (concat, takeWhile)
 
 
@@ -65,13 +64,13 @@
       Nothing -> return $ M.fromList pairs
 
 -- | Parses an inline table of key-value pairs.
-inlineTable :: (TomlM m) => Parser m Node
+inlineTable :: (TomlM m) => Parser m (Either (S.Set (ErrorFancy Void)) Node)
 inlineTable = do
     pairs <- between (char '{') (char '}') (skipSpaces *> separatedValues <* skipSpaces)
-    optional (char '\n')
-    case maybeDupe (traceShowId $ map fst pairs) of
-      Just k  -> throwParser $ "Cannot redefine key " ++ unpack k
-      Nothing -> return $ VTable $ M.fromList pairs
+    case maybeDupe (map fst pairs) of
+      Just k  ->
+        pure $ Left (S.fromList [ErrorFail $ "Cannot redefine key " ++ unpack k ])
+      Nothing -> pure $ Right $ VTable $ M.fromList pairs
   where
     skipSpaces      = many (satisfy isSpc)
     separatedValues = sepBy (skipSpaces *> assignment <* skipSpaces) comma
@@ -119,7 +118,10 @@
 assignment = do
     k <- (pack <$> some keyChar) <|> anyStr'
     many (satisfy isSpc) >> char '=' >> skipBlanks
-    v <- value
+    v' <- value
+    v <- case v' of
+        Right x -> pure x
+        Left y  -> fancyFailure y
     return (k, v)
   where
     -- TODO: Follow the spec, e.g.: only first char cannot be '['.
@@ -127,13 +129,13 @@
 
 
 -- | Parses a value.
-value :: (TomlM m) => Parser m Node
-value = (try array       <?> "array")
-    <|> (try boolean     <?> "boolean")
-    <|> (try anyStr      <?> "string")
-    <|> (try datetime    <?> "datetime")
-    <|> (try float       <?> "float")
-    <|> (try integer     <?> "integer")
+value :: (TomlM m) => Parser m (Either (S.Set (ErrorFancy Void)) Node)
+value = (pure <$> try array       <?> "array")
+    <|> (pure <$> try boolean     <?> "boolean")
+    <|> (pure <$> try anyStr      <?> "string")
+    <|> (pure <$> try datetime    <?> "datetime")
+    <|> (pure <$> try float       <?> "float")
+    <|> (pure <$> try integer     <?> "integer")
     <|> (inlineTable     <?> "inline table")
 
 
@@ -216,7 +218,7 @@
     e <- (oneOf ("eE" :: String) *> intStr) <|> return "0"
     return . read . join $ [n, ".", d, "e", e]
   where
-    sign    = string "-" <|> (char '+' >> return "") <|> return ""
+    sign    = (T.singleton <$> char '-') <|> (char '+' >> return "") <|> return ""
     uintStr = (:) <$> digitChar <*> many (optional (char '_') *> digitChar)
     intStr  = do s <- T.unpack <$> sign
                  u <- uintStr
diff --git a/test/Text/Toml/Parser/Spec.hs b/test/Text/Toml/Parser/Spec.hs
--- a/test/Text/Toml/Parser/Spec.hs
+++ b/test/Text/Toml/Parser/Spec.hs
@@ -8,7 +8,6 @@
 import qualified Data.Vector         as V
 import           Test.Tasty          (TestTree)
 import           Test.Tasty.Hspec
-import           Text.Toml
 import           Text.Toml.Parser
 
 
@@ -419,11 +418,11 @@
   describe "Parser.tomlDoc inline tables" $ do
 
     it "should parse an empty inline table" $
-      testParser inlineTable "{}" $ VTable (fromList [])
+      testParser inlineTable "{}" $ Right $ VTable (fromList [])
 
     it "should parse simple inline tables" $
       testParser inlineTable "{ a = 8 , b = \"things\" }" $
-        VTable (fromList [ ("a" , VInteger 8) , ("b", VString "things") ])
+        Right $ VTable (fromList [ ("a" , VInteger 8) , ("b", VString "things") ])
 
     it "should not parse simple inline tables with newline " $
       testParserFails inlineTable "{ a = 8 , \n b = \"things\" }"
diff --git a/test/Text/TomlSpec.hs b/test/Text/TomlSpec.hs
--- a/test/Text/TomlSpec.hs
+++ b/test/Text/TomlSpec.hs
@@ -4,7 +4,6 @@
 
 import           Data.List.NonEmpty
 import qualified Data.Set           as Set
-import           Data.Text          (Text)
 import           Test.Hspec
 import           Text.Megaparsec
 import           Text.Toml
@@ -13,5 +12,5 @@
 hspecTests = do
   describe "parser" $ do
     it "should not parse re-assignment of key" $ do
-      let actual = parseTomlDoc "noSrc" "q={k=42, k=43}"
+      let actual = parseTomlDoc "noSrc" "q={k=42, k=43}\nd=str"
       actual `shouldBe` Left (FancyError ((SourcePos "noSrc" (mkPos 1) (mkPos 15)) :| []) (Set.fromList [(ErrorFail "Cannot redefine key k")]))