diff --git a/.DS_Store b/.DS_Store
Binary files a/.DS_Store and b/.DS_Store differ
diff --git a/._.DS_Store b/._.DS_Store
Binary files a/._.DS_Store and b/._.DS_Store differ
diff --git a/._LICENSE b/._LICENSE
Binary files a/._LICENSE and b/._LICENSE differ
diff --git a/._ParserFunction.cabal b/._ParserFunction.cabal
Binary files a/._ParserFunction.cabal and b/._ParserFunction.cabal differ
diff --git a/._Setup.hs b/._Setup.hs
Binary files a/._Setup.hs and b/._Setup.hs differ
diff --git a/._Text b/._Text
Binary files a/._Text and b/._Text differ
diff --git a/ParserFunction.cabal b/ParserFunction.cabal
--- a/ParserFunction.cabal
+++ b/ParserFunction.cabal
@@ -1,19 +1,18 @@
 name:          ParserFunction
-version:       0.0.4
+version:       0.0.5
 cabal-version: >= 1.6
 license:       BSD3
 license-file:  LICENSE
 author:        Enzo Haussecker
 maintainer:    ehaussecker@gmail.com
 category:      Parsing
-synopsis:      Utilities for parsing and evaluating string-expressions.
+synopsis:      Utilities for parsing and evaluating mathematical expressions.
 description:
-    ParserFunction provides utilities for parsing and evaluating string-expressions.
-    The centerpiece of this module is a function called @evalStrExpr@,
-    which evaluates a string-expression using a variable lookup map.
-    Example: @evalStrExpr@ \"exp(x)\" [(\'x\',1)] gives 2.718281828459045.
-    More examples can be found by viewing the source code for this module.
-    This module also exports all supporting functionality.
+    ParserFunction provides utilities for parsing and evaluating mathematical expressions.
+    The central parsing function in this package is @stringToExpr@, which parses an expression
+    (as a string) and returns an expression tree of type Expr (or nothing if the string is malformed).
+    Expressions can be evaluated using the function @evaluateExpression@. Examples of these
+    functions can be found by viewing the source code for this package.
 
 build-type: Simple
 
diff --git a/Text/.DS_Store b/Text/.DS_Store
Binary files a/Text/.DS_Store and b/Text/.DS_Store differ
diff --git a/Text/._.DS_Store b/Text/._.DS_Store
Binary files a/Text/._.DS_Store and b/Text/._.DS_Store differ
diff --git a/Text/._ParserCombinators b/Text/._ParserCombinators
Binary files a/Text/._ParserCombinators and b/Text/._ParserCombinators differ
diff --git a/Text/ParserCombinators/.DS_Store b/Text/ParserCombinators/.DS_Store
Binary files a/Text/ParserCombinators/.DS_Store and b/Text/ParserCombinators/.DS_Store differ
diff --git a/Text/ParserCombinators/._.DS_Store b/Text/ParserCombinators/._.DS_Store
Binary files a/Text/ParserCombinators/._.DS_Store and b/Text/ParserCombinators/._.DS_Store differ
diff --git a/Text/ParserCombinators/._Parsec b/Text/ParserCombinators/._Parsec
Binary files a/Text/ParserCombinators/._Parsec and b/Text/ParserCombinators/._Parsec differ
diff --git a/Text/ParserCombinators/Parsec/._.DS_Store b/Text/ParserCombinators/Parsec/._.DS_Store
Binary files a/Text/ParserCombinators/Parsec/._.DS_Store and b/Text/ParserCombinators/Parsec/._.DS_Store differ
diff --git a/Text/ParserCombinators/Parsec/._ParserFunction.hs b/Text/ParserCombinators/Parsec/._ParserFunction.hs
Binary files a/Text/ParserCombinators/Parsec/._ParserFunction.hs and b/Text/ParserCombinators/Parsec/._ParserFunction.hs differ
diff --git a/Text/ParserCombinators/Parsec/ParserFunction.hs b/Text/ParserCombinators/Parsec/ParserFunction.hs
--- a/Text/ParserCombinators/Parsec/ParserFunction.hs
+++ b/Text/ParserCombinators/Parsec/ParserFunction.hs
@@ -1,20 +1,28 @@
 ---   ParserFunction
 ---   by Enzo Haussecker
 
----   The centerpiece of this module is a function called: evalStrExpr, 
----   which evaluates a string-expression using a variable lookup map.
+---   ParserFunction provides utilities for parsing and evaluating mathematical expressions. 
+---   The central parsing function in this package is stringToExpr, which parses an expression 
+---   (as a string) and returns an expression tree of type Expr (or nothing if the string is malformed). 
 
----   Examples of evalStrExpr are as fallows.
+---   Examples of stringToExpr are as fallows.
 
----   > evalStrExpr "5 - 2" []
+---   > stringToExpr "cos(x^2)+4*(1+y)"
+---   Just (Add (Cos (Pow (Var 'x') (Num 2.0))) (Mul (Num 4.0) (Add (Num 1.0) (Var 'y'))))
+
+---   Expressions can be evaluated using the function evaluateExpression. Example: 
+
+---   Examples of evaluateExpression are as fallows.
+
+---   > evaluateExpression "5 - 2" []
 ---   3.0
----   > evalStrExpr "x^2 + y" [('x',2),('y',3)]
+---   > evaluateExpression "x^2 + y" [('x',2),('y',3)]
 ---   7.0
----   > evalStrExpr "cos(x)" [('x',pi)]
+---   > evaluateExpression "cos(x)" [('x',pi)]
 ---   -1.0
 
 module Text.ParserCombinators.Parsec.ParserFunction
-    (Expr,evalStrExpr,strToExpr,buildExpr,expressionTable,factor,variables,number,evaluate) where
+    (Expr,evaluateExpression,stringToExpr,buildExpr,expressionTable,factor,variables,number,evaluate) where
 
 import Text.ParserCombinators.Parsec.Expr 
 import Text.ParserCombinators.Parsec
@@ -37,18 +45,17 @@
           | Sec Expr      | Csc Expr      | Cot Expr
           | Mul Expr Expr | Add Expr Expr | Exp Expr deriving (Show, Eq, Ord)
 
---- evalStrExpr evaluates a string-expression s using the variable lookup map m. 
-evalStrExpr :: String -> [(Char,Double)] -> Double
-evalStrExpr s m = evaluate (M.fromAscList $ caseMap m) (fromMaybe failing $ strToExpr s)
+--- evaluateExpression evaluates a mathematical expression s using the variable map m. 
+evaluateExpression :: String -> [(Char,Double)] -> Double
+evaluateExpression s m = evaluate (M.fromAscList $ caseMap m) (fromMaybe failing $ stringToExpr s)
     where 
         caseMap x = fmap (\ (a, b) -> ([toLower a], b)) x
         failing   = error "Parser error in expression"
 
---- strToExpr parses a string-expression and returns an Expr expression, 
---- or nothing if the string is malformed. A failing example is "2+-2". 
---- The correct format should be "2+(-2)".
-strToExpr :: String -> Maybe Expr
-strToExpr xs = if any (==True) (symbols failingSymbols xs)
+--- stringToExpr parses an expression and returns an expression tree of type Expr, 
+--- (or nothing if the string is malformed).
+stringToExpr :: String -> Maybe Expr
+stringToExpr xs = if any (==True) (symbols failingSymbols xs)
                   then Nothing
                   else either (const Nothing) (Just) (parse buildExpr "" handleString)
     where
@@ -59,7 +66,6 @@
                           "/^","/*","//","/+","/-","+^","+*","+/","++","+-",
                           "-^","-*","-/","-+","--"]
 
---- buildExpr is the fundamental parsing function.
 buildExpr :: Parser Expr
 buildExpr = buildExpressionParser expressionTable factor