Added haddock documentation

src/Semantic/ExpressionChecker.hs

@@ -6,6 +6,7 @@ import Data.Maybe
 import Model.Type
 import Semantic.TypeChecker
   
+-- |A declared variable or function
 data Symbol = Var{
    varName :: String,
    declaredType :: Type
@@ -16,6 +17,7 @@ data Symbol = Var{
    returnType :: Type
    }
   
+-- |A map of the predefined functions, their arguments and their return type
 defaultMap :: [Symbol]
 defaultMap = [
   Func "or" [BasicType "Boolean", BasicType "Boolean"] (BasicType "Boolean"),
@@ -52,6 +54,7 @@ defaultMap = [
   Func "count" [BasicType "Any"] (BasicType "Integer")
   ]
 
+-- |Checks whether a function is valid (inputs, outputs are of valid type and all variables are defined) and adds it to the symbol table
 addFunction :: ([Type], [Symbol]) -> Function -> Either [TypeCheckError] [Symbol]
 addFunction (definedTypes, definedSymbols) (MakeFunction name _ inps out _)
     | null (lefts checkedInputs) && isRight checkedOutput = Right $ Func name (map attributeType (rights checkedInputs)) (attributeType $ fromRightUnsafe checkedOutput) : allSymbols
@@ -62,10 +65,12 @@ addFunction (definedTypes, definedSymbols) (MakeFunction name _ inps out _)
         checkedOutput = head $ checkAttributes definedTypes [out]
         allSymbols = addVariables definedSymbols inps
         
+-- |Adds a newly defined variable to the symbol table
 addVariables :: [Symbol] -> [TypeAttribute] -> [Symbol]
 addVariables s [] = s
 addVariables s ((MakeTypeAttribute name typ _ _)  : vars) = Var name typ : addVariables s vars
         
+-- |Checks the type of a given expression
 checkExpression :: [Symbol] -> Expression -> Either TypeCheckError Type
 checkExpression symbolMap (Variable var) = findVarType var symbolMap
 checkExpression _ (Int _) = Right $ BasicType "Integer"
@@ -78,10 +83,12 @@ checkExpression symbolMap (PrefixExp name ex) = checkFunctionCall symbolMap name
 checkExpression symbolMap (Function name exps) = checkFunctionCall symbolMap name (map (checkExpression symbolMap) exps)
 checkExpression symbolMap (PostfixExp name ex) = checkFunctionCall symbolMap name [checkExpression symbolMap ex]
 checkExpression symbolMap (InfixExp name ex1 ex2) = checkFunctionCall symbolMap name (checkExpression symbolMap ex1: [checkExpression symbolMap ex2])
+-- |Checks if the condition of an if expression is of type boolean, and then checks the expression of the then statement
 checkExpression symbolMap (IfSimple cond ex)
     | isRight condType && isRight (typeMatch (fromRightUnsafe condType) (BasicType "Boolean")) = checkExpression symbolMap ex
     | otherwise = Left IfConditionNotBoolean
     where condType = checkExpression symbolMap cond
+-- |Checks if the condition of the if statement is of type boolean, and then checks that both the then and else statements have the same type
 checkExpression symbolMap (IfElse cond ex1 ex2)
     | isRight condType || isRight (typeMatch (fromRightUnsafe condType) (BasicType "Boolean")) = Left IfConditionNotBoolean 
     | isRight ex1Type || isRight ex2Type || isRight (typeMatch (fromRightUnsafe ex1Type) (fromRightUnsafe ex2Type)) = Left IfExpressionsDifferentTypes
@@ -90,12 +97,14 @@ checkExpression symbolMap (IfElse cond ex1 ex2)
             ex1Type = checkExpression symbolMap ex1
             ex2Type = checkExpression symbolMap ex2
 
+-- |Checks that all the expressions in a list have compatible types
 checkList :: [Symbol] -> [Expression] -> Either TypeCheckError Type
 checkList symbs exps
     | isRight typ && fromRightUnsafe typ == BasicType "Any" = Right $ BasicType "Empty"
     | otherwise = typ
     where typ = checkList1 symbs exps (BasicType "Any") 
 
+-- |Auxiliary function for the check list function
 checkList1 :: [Symbol] -> [Expression] -> Type -> Either TypeCheckError Type
 checkList1 _ [] typ = Right typ
 checkList1 symbs (ex : exps) typ 
@@ -106,6 +115,7 @@ checkList1 symbs (ex : exps) typ
         exTyp = checkExpression symbs ex 
         match = typeMatch typ (fromRightUnsafe exTyp)
 
+-- |Checks whether the function that is called is already defined with the same argument types
 checkFunctionCall :: [Symbol] -> String -> [Either TypeCheckError Type] -> Either TypeCheckError Type
 checkFunctionCall [] fun args = Left $ UndefinedFunction $ "Undefined function: \"" ++ fun ++ "\" [" ++ concatMap typeName (rights args) ++ "]"
 checkFunctionCall ((Func n a r):symbolMap) name args
@@ -116,6 +126,7 @@ checkFunctionCall ((Func n a r):symbolMap) name args
 checkFunctionCall (_:symbolMap) name args = checkFunctionCall symbolMap name args 
 
 --Try to match 2nd type to first type
+-- |Checks whether two types are compatible
 typeMatch :: Type -> Type -> Either TypeCheckError Type
 typeMatch (BasicType "Any") x = Right x
 typeMatch (BasicType "Double") (BasicType "Integer") = Right $ BasicType "Dobule"
@@ -127,6 +138,7 @@ typeMatch s s2
     | isJust $ superType s2 = typeMatch s (fromJust $ superType s2)
     | otherwise = Left $ TypeMismatch (typeName s) (typeName s2)
 
+-- |Looks in the symbol map for the type of a variable
 findVarType :: String -> [Symbol] -> Either TypeCheckError Type
 findVarType var [] = Left $ UndefinedVariable var
 findVarType x ((Var name typ):symbols)