Introduced a cyclic dependency

src/Ubc/Parse/Syntax/Statement.hs

@@ -1,11 +1,49 @@
 module Ubc.Parse.Syntax.Statement
 ( Statement(..)
-)
+, parseStatement)
 where
 
 import Ubc.Parse.Syntax.VariableType (VariableType)
-import Ubc.Parse.Syntax.Expression (Expression)
+import Ubc.Parse.Syntax.Expression (Expression, expressionParser)
+import Ubc.Parse.Syntax.TypeExpression (TypeExpression)
+import Text.Parsec (choice, ParsecT, try)
+import qualified Ubc.Parse.Syntax.Language as UbcLanguage
+import qualified Ubc.Parse.Syntax.VariableType as VariableType
+import qualified Ubc.Parse.Syntax.TypeExpression as TypeExpression
+import Ubc.Parse.Syntax.ParserState (ParserState)
+import Control.Monad ((<$!>))
 
 type VariableName = String
+type TypeName = String
 
 data Statement = VariableDefinition VariableType VariableName Expression
+        | TypeDefinition TypeName TypeExpression
+        | ExpressionStatement Expression
+
+parseStatement :: Monad m => ParsecT String ParserState m Statement
+parseStatement = choice [ variableDefinition
+                        , typeDefinition
+                        , ExpressionStatement <$!> expressionParser
+                        ]
+
+typeDefinition :: Monad m => ParsecT String ParserState m Statement
+typeDefinition = do
+        UbcLanguage.reserved "type"
+
+        name <- UbcLanguage.identifier
+
+        UbcLanguage.reservedOperator "="
+
+        TypeDefinition name <$> TypeExpression.parseTypeExpression
+
+
+variableDefinition :: Monad m => ParsecT String u m Statement
+variableDefinition = do
+        (variableType, variableName) <- try $ do
+                variableType <- UbcLanguage.typeName
+                variableName <- UbcLanguage.identifier
+                _ <- UbcLanguage.reservedOperator "="
+                return (VariableType.fromString variableType, variableName)
+
+        VariableDefinition variableType variableName <$> expressionParser
+