Added haddock documentation

app/Main.hs

@@ -13,43 +13,53 @@ import PrettyPrinter.Function
 import Semantic.TypeChecker
 import Semantic.ExpressionChecker
 import Semantic.FunctionChecker
-import Model.Function
 import Model.Type
 import System.Environment.Blank (getArgs)
 import Model.Enum
 import Data.Either
 
 -- :set args resources/testAll.rosetta resources/Generated/testAll.hs
+-- |Reads a rosetta string from the first input argument and writes a haskell output to the file given as a second argument
 main :: IO ()
 main = do
     args <- getArgs
     rosettaString <- readFile $ head args
+    -- |Parse the string read from the input file
     case parse rosettaParser "" (Text.pack rosettaString) of
         Left errorBundle -> print (errorBundlePretty errorBundle)
         Right objs -> do
+            -- |Write the haskell string into the second argument
             writeFile (args !! 1) (printObjects (definedTypes, definedFunctions) objs) 
             where 
+                -- |Adds all the function definitions from the file into the symbol table
                 definedFunctions = addNewFunctions (definedTypes, defaultMap) objs
+                -- |Adds all the new data types into the symbol table 
                 definedTypes = addNewTypes [] objs
-      
+   
+-- |Reads a rosetta string from the first input argument, parses that string and then writes a haskell output to the file given as a second argument   
 printObjects :: ([Type], [Symbol]) -> [RosettaObject] -> String
 printObjects (t, s) objs
     | null (lefts finalString) = concat $ rights finalString
     | otherwise = error $ show $ lefts finalString
     where finalString = map (printObject (t, s)) objs  
-                    
+          
+-- |Checks the RosettaObject for type errors and then converts it into a haskell string         
 printObject :: ([Type], [Symbol]) -> RosettaObject -> Either [TypeCheckError] String
+-- |Checks the type and attributes of a type and then converts it
 printObject (definedTypes, _) (TypeObject t)
     | isRight checked = Right $ printType $ fromRightUnsafe checked
     | otherwise = Left $ fromLeftUnsafe checked
     where checked = checkType definedTypes t
+-- |Enum is converted directly since no type checks are necessary
 printObject _ (EnumObject e) = Right $ printEnum e
+-- |Checks the function inputs, output and assignment and converts it
 printObject (definedTypes, definedFunctions) (FunctionObject fun)
     | isRight checked = Right $ printFunction $ fromRightUnsafe checked
     | otherwise = Left $ fromLeftUnsafe checked
     where 
         checked = checkFunction (definedTypes, definedFunctions) fun
 
+-- |Adds new defined functions into the symbol table
 addNewFunctions :: ([Type], [Symbol]) -> [RosettaObject] -> [Symbol]
 addNewFunctions (_, s) [] = s
 addNewFunctions (t, s) ((FunctionObject f):os)
@@ -58,65 +68,28 @@ addNewFunctions (t, s) ((FunctionObject f):os)
     where definedFunctions = addFunction (t, addNewFunctions (t, s) os) f
 addNewFunctions (t, s) (_:os) = addNewFunctions (t, s) os
 
+-- |Adds new defined types into the symbol table
 addNewTypes :: [Type] -> [RosettaObject] -> [Type]
 addNewTypes l [] = l
 addNewTypes defined (TypeObject o: os) = addDefinedTypes (addNewTypes defined os) [o] 
 addNewTypes defined (EnumObject (MakeEnum name _ _): os) = addDefinedTypes (addNewTypes defined os) [MakeType name Nothing Nothing []]
 addNewTypes defined (_ :os) = addNewTypes defined os
 
+-- |Parses any supported Rosetta types into a list of RosettaObject
 rosettaParser :: Parser [RosettaObject]
 rosettaParser = many (try parseEnum <|> try parseType <|> try parseFunction) <* eof
 
+-- |Reads an enum into a RosettaObject
 parseEnum :: Parser RosettaObject
 parseEnum = do
     EnumObject <$> enumParser
     
+-- |Parse a type into a RosettaObject
 parseType :: Parser RosettaObject
 parseType = do
     TypeObject <$> typeParser
     
+-- |Parse a function into a RosettaObject
 parseFunction :: Parser RosettaObject
 parseFunction = do
-    FunctionObject <$> functionParser
-
-testEnum :: IO()
-testEnum = do
-    rosettaString <- readFile "resources/Enums/testEnum1.rosetta"
-    case parse enumParser "" (Text.pack rosettaString) of
-        Left errorBundle -> print errorBundle
-        Right enum -> 
-            do
-                putStrLn $ printEnum enum
-                writeFile "resources/Generated/generatedEnum.hs" (printEnum enum) 
-        
-testTypeParser :: IO()
-testTypeParser = do
-    rosettaString <- readFile "resources/Types/testType1.rosetta"
-    case parse typeParser "" (Text.pack rosettaString) of
-        Left errorBundle -> print (errorBundlePretty errorBundle)
-        Right typ -> 
-            do
-                putStrLn $ printType typ
-                print typ
-                writeFile "resources/Generated/generatedType.hs" (printType typ) 
-              
-testTypeChecker :: IO ()
-testTypeChecker = do
-    rosettaString <- readFile "src/TestFiles/testType.rosetta"
-    case parse (many typeParser) "" (Text.pack rosettaString) of
-        Left errorBundle -> print (errorBundlePretty errorBundle)
-        Right typ -> 
-            do
-                print $ map (checkAttributes definedTypes . typeAttributes) typ
-                where definedTypes = addDefinedTypes [] typ
-                
-testFunc :: IO()
-testFunc = do
-    rosettaString <- readFile "resources/testFunction.rosetta"
-    case parse functionParser "" (Text.pack rosettaString) of
-        Left errorBundle -> print (errorBundlePretty errorBundle)
-        Right fun -> 
-            do
-                print $ printFunctionSignature fun
-                print (assignment fun)
-                writeFile "resources/Generated/generatedFunction.hs" (show $ printFunctionSignature fun) 
+    FunctionObject <$> functionParser