diff --git a/Nix/Parser.hs b/Nix/Parser.hs
index 1055540..7e637ab 100644
--- a/Nix/Parser.hs
+++ b/Nix/Parser.hs
@@ -80,8 +80,8 @@ nixPath = try $ fmap mkPath $ mfilter ('/' `elem`) $ some (oneOf "A-Za-z_0-9.:/"
 
 nixLet :: Parser NExpr
 nixLet =  (Fix .) . NLet
-      <$> (symbol "let" *> nixBinders)
-      <*> (whiteSpace *> symbol "in" *> nixApp)
+      <$> (reserved "let" *> nixBinders)
+      <*> (whiteSpace *> reserved "in" *> nixApp)
 
 -- | This is a bit tricky because we don't know whether we're looking at a set
 --   or a lambda until we've looked ahead a bit.  And then it may be neither,
@@ -89,14 +89,14 @@ nixLet =  (Fix .) . NLet
 setLambdaStringOrSym :: Bool -> Parser NExpr
 setLambdaStringOrSym allowLambdas = do
     trace "setLambdaStringOrSym" $ return ()
-    x <- try (lookAhead symName)
+    x <- try (lookAhead identifier)
         <|> try (lookAhead (singleton <$> char '{'))
         <|> return ""
     if x == "rec" || x == "{"
         then setOrArgs
         else do
             trace "might still have a lambda" $ return ()
-            y <- try (lookAhead (True <$ (symName *> whiteSpace *> symbolic ':')))
+            y <- try (lookAhead (True <$ (identifier *> whiteSpace *> symbolic ':')))
                 <|> return False
             trace ("results are = " ++ show y) $ return ()
             if y
@@ -105,9 +105,6 @@ setLambdaStringOrSym allowLambdas = do
                     else error "Unexpected lambda"
                 else keyName <?> "string"
 
-symName :: Parser Text
-symName = pack <$> ((:) <$> letter <*> many (alphaNum <|> oneOf "._"))
-
 stringish :: Parser NExpr
 stringish =  (char '"' *> (merge <$> manyTill stringChar (char '"')))
          <|> (char '$' *> braces nixApp)
@@ -120,12 +117,12 @@ stringish =  (char '"' *> (merge <$> manyTill stringChar (char '"')))
 
 argExpr :: Parser NExpr
 argExpr =  (Fix . NArgSet . Map.fromList <$> argList)
-       <|> ((mkSym <$> symName) <?> "argname")
+       <|> ((mkSym <$> identifier) <?> "argname")
   where
     argList =  braces ((argName <* whiteSpace) `sepBy` symbolic ',')
            <?> "arglist"
 
-    argName = (,) <$> (symName <* whiteSpace)
+    argName = (,) <$> (identifier <* whiteSpace)
                   <*> optional (symbolic '?' *> nixExpr False)
 
 nvPair :: Parser (NExpr, NExpr)
@@ -135,12 +132,12 @@ nixBinders :: Parser [(NExpr, NExpr)]
 nixBinders = nvPair `endBy` symbolic ';'
 
 keyName :: Parser NExpr
-keyName = (stringish <|> (mkSym <$> symName)) <* whiteSpace
+keyName = (stringish <|> (mkSym <$> identifier)) <* whiteSpace
 
 setOrArgs :: Parser NExpr
 setOrArgs = do
     trace "setOrArgs" $ return ()
-    sawRec <- try (symbol "rec" *> pure True) <|> pure False
+    sawRec <- try (reserved "rec" *> pure True) <|> pure False
     trace ("Do we have sawRec: " ++ show sawRec) $ return ()
     haveSet <-
         if sawRec
diff --git a/Nix/Parser/Library.hs b/Nix/Parser/Library.hs
index 10ea835..7971d94 100644
--- a/Nix/Parser/Library.hs
+++ b/Nix/Parser/Library.hs
@@ -2,12 +2,13 @@
 
 module Nix.Parser.Library ( module Nix.Parser.Library, module X ) where
 
-import           Control.Applicative
+import Control.Applicative
 
 #if USE_PARSEC
 
 import           Control.Monad
 import           Control.Monad.IO.Class
+import           Data.Text as T
 import           Data.Text.IO as T
 import           Text.Parsec as X hiding ((<|>), many, optional)
 import           Text.Parsec.Expr as X
@@ -22,7 +23,7 @@ lexer = P.makeTokenParser P.LanguageDef
     , P.commentLine     = "#"
     , P.nestedComments  = True
     , P.identStart      = letter <|> char '_'
-    , P.identLetter     = alphaNum <|> char '_'
+    , P.identLetter     = alphaNum <|> oneOf "_."
     , P.opStart         = oneOf ":!#$%&*+./<=>?@\\^|-~"
     , P.opLetter        = oneOf "@"
     , P.reservedNames   =
@@ -49,8 +50,14 @@ brackets = P.brackets lexer
 braces :: Parser a -> Parser a
 braces = P.braces lexer
 
-symbol :: String -> Parser String
-symbol str = string str <* whiteSpace
+identifier :: Parser Text
+identifier = pack <$> P.identifier lexer
+
+reserved :: String -> Parser ()
+reserved = P.reserved lexer
+
+symbol :: String -> Parser Text
+symbol str = pack <$> P.symbol lexer str
 
 symbolic :: Char -> Parser Char
 symbolic c = char c <* whiteSpace
diff --git a/default.nix b/default.nix
index ca34fd3..7ec70d0 100644
--- a/default.nix
+++ b/default.nix
@@ -8,6 +8,7 @@ cabal.mkDerivation (self: rec {
   src = ./.;
   isLibrary = true;
   isExecutable = true;
+  noHaddock = true;
   buildDepends = [
     ansiWlPprint
     text