diff --git a/calculator.cabal b/calculator.cabal
--- a/calculator.cabal
+++ b/calculator.cabal
@@ -1,5 +1,5 @@
 name:                calculator
-version:             0.1.5.0
+version:             0.1.5.1
 synopsis:            A calculator repl.
 description:         A calculator repl that processes mathematical expressions.
                      Does basic arithmetic, and provides pre-defined basic mathematical functions.
diff --git a/src/Calculator/Parser/Expr.hs b/src/Calculator/Parser/Expr.hs
--- a/src/Calculator/Parser/Expr.hs
+++ b/src/Calculator/Parser/Expr.hs
@@ -8,7 +8,7 @@
 
 --------------------------------------------------------------------------------
 
-import           Control.Applicative           ((<$>), (<*))
+import           Control.Applicative           ((<$>))
 import           Text.ParserCombinators.Parsec
 
 --------------------------------------------------------------------------------
@@ -16,17 +16,17 @@
 
 parseExpr :: Parser Expr
 parseExpr = do
-  term <- parseTerm     <* spaces
-  rest <- parseRestExpr <* spaces
+  term <- parseTerm
+  rest <- parseRestExpr
   if null rest
     then return term
     else return $ BinOp (term, rest)
 
 parseRestExpr :: Parser [(Operator, Expr)]
 parseRestExpr = many $ do
-  oper <- oneOf "+-" <* spaces
+  oper <- oneOf "+-"
   let (Just op) = lookup oper binaryOps
-  expr <- parseTerm  <* spaces
+  expr <- parseTerm
   return (op, expr)
 
 --------------------------------------------------------------------------------
@@ -34,17 +34,17 @@
 
 parseTerm :: Parser Expr
 parseTerm = do
-  fact <- parseFact     <* spaces
-  rest <- parseRestTerm <* spaces
+  fact <- parseFact
+  rest <- parseRestTerm
   if null rest
     then return fact
     else return $ BinOp (fact, rest)
 
 parseRestTerm :: Parser [(Operator, Expr)]
 parseRestTerm = many $ do
-  oper <- oneOf "*/" <* spaces
+  oper <- oneOf "*/"
   let (Just op) = lookup oper binaryOps
-  expr <- parseFact  <* spaces
+  expr <- parseFact
   return (op, expr)
 
 --------------------------------------------------------------------------------
@@ -53,8 +53,8 @@
 
 parseFact :: Parser Expr
 parseFact = do
-  val <- parseVal   <* spaces
-  pow <- parsePower <* spaces
+  val <- parseVal
+  pow <- parsePower
   if constEq (Constant 1) (snd pow)
     then return val
     else return $ BinOp (val, [pow])
@@ -62,9 +62,8 @@
 parsePower :: Parser (Operator, Expr)
 parsePower = let (Just op) = lookup '^' binaryOps
              in option (op, Constant 1) $ do
-               _    <- spaces
-               _    <- char '^'  <* spaces
-               fact <- parseFact <* spaces
+               _    <- char '^'
+               fact <- parseFact
                return (op, fact)
 
 --------------------------------------------------------------------------------
@@ -82,11 +81,10 @@
 
 parseCall :: Parser Expr
 parseCall = do
-  _     <- spaces
-  ident <- optionMaybe parseId <* spaces
-  _     <- char '('            <* spaces
-  expr  <- parseExpr           <* spaces
-  _     <- char ')'            <* spaces
+  ident <- optionMaybe parseId
+  _     <- char '('
+  expr  <- parseExpr
+  _     <- char ')'
   return $ case ident of
              Nothing -> expr
              Just s  -> Function s expr