[feature] Type checker for the 'ForStmt'

Author: rbonifacio

src/parser/parser_type.rs

@@ -13,6 +13,28 @@ use crate::ir::ast::{Type, ValueConstructor};
 
 use crate::parser::parser_common::{identifier, keyword, separator};
 
+// String constants for type names
+const INT_TYPE: &str = "Int";
+const REAL_TYPE: &str = "Real";
+const BOOLEAN_TYPE: &str = "Boolean";
+const STRING_TYPE: &str = "String";
+const UNIT_TYPE: &str = "Unit";
+const ANY_TYPE: &str = "Any";
+
+// String constants for special type constructors
+const MAYBE_TYPE: &str = "Maybe";
+const RESULT_TYPE: &str = "Result";
+
+// String constants for ADT keywords
+const DATA_KEYWORD: &str = "data";
+const END_KEYWORD: &str = "end";
+
+// String constants for operators and symbols
+const FUNCTION_ARROW: &str = "->";
+const PIPE_SYMBOL: &str = "|";
+const COLON_SYMBOL: &str = ":";
+const COMMA_SYMBOL: &str = ",";
+
 pub fn parse_type(input: &str) -> IResult<&str, Type> {
     alt((
         parse_basic_types,
@@ -28,20 +50,20 @@ pub fn parse_type(input: &str) -> IResult<&str, Type> {
 fn parse_basic_types(input: &str) -> IResult<&str, Type> {
     map(
         alt((
-            keyword("Int"),
-            keyword("Real"),
-            keyword("Boolean"),
-            keyword("String"),
-            keyword("Unit"),
-            keyword("Any"),
+            keyword(INT_TYPE),
+            keyword(REAL_TYPE),
+            keyword(BOOLEAN_TYPE),
+            keyword(STRING_TYPE),
+            keyword(UNIT_TYPE),
+            keyword(ANY_TYPE),
         )),
         |t| match t {
-            "Int" => Type::TInteger,
-            "Real" => Type::TReal,
-            "Boolean" => Type::TBool,
-            "String" => Type::TString,
-            "Unit" => Type::TVoid,
-            "Any" => Type::TAny,
+            INT_TYPE => Type::TInteger,
+            REAL_TYPE => Type::TReal,
+            BOOLEAN_TYPE => Type::TBool,
+            STRING_TYPE => Type::TString,
+            UNIT_TYPE => Type::TVoid,
+            ANY_TYPE => Type::TAny,
             _ => unreachable!(),
         },
     )(input)
@@ -62,7 +84,10 @@ fn parse_tuple_type(input: &str) -> IResult<&str, Type> {
     map(
         tuple((
             preceded(multispace0, char('(')),
-            preceded(multispace0, separated_list1(separator(","), parse_type)),
+            preceded(
+                multispace0,
+                separated_list1(separator(COMMA_SYMBOL), parse_type),
+            ),
             preceded(multispace0, char(')')),
         )),
         |(_, ts, _)| Type::TTuple(ts),
@@ -72,7 +97,7 @@ fn parse_tuple_type(input: &str) -> IResult<&str, Type> {
 fn parse_maybe_type(input: &str) -> IResult<&str, Type> {
     map(
         tuple((
-            preceded(multispace0, keyword("Maybe")),
+            preceded(multispace0, keyword(MAYBE_TYPE)),
             preceded(multispace0, char('[')),
             preceded(multispace0, parse_type),
             preceded(multispace0, char(']')),
@@ -84,7 +109,7 @@ fn parse_maybe_type(input: &str) -> IResult<&str, Type> {
 fn parse_result_type(input: &str) -> IResult<&str, Type> {
     map(
         tuple((
-            preceded(multispace0, keyword("Result")),
+            preceded(multispace0, keyword(RESULT_TYPE)),
             preceded(multispace0, char('[')),
             preceded(multispace0, parse_type),
             preceded(multispace0, char(',')),
@@ -99,9 +124,12 @@ fn parse_function_type(input: &str) -> IResult<&str, Type> {
     map(
         tuple((
             preceded(multispace0, char('(')),
-            preceded(multispace0, separated_list0(separator(","), parse_type)),
+            preceded(
+                multispace0,
+                separated_list0(separator(COMMA_SYMBOL), parse_type),
+            ),
             preceded(multispace0, char(')')),
-            preceded(multispace0, tag("->")),
+            preceded(multispace0, tag(FUNCTION_ARROW)),
             preceded(multispace0, parse_type),
         )),
         |(_, t_args, _, _, t_ret)| Type::TFunction(Box::new(Some(t_ret)), t_args),
@@ -111,11 +139,11 @@ fn parse_function_type(input: &str) -> IResult<&str, Type> {
 fn parse_adt_type(input: &str) -> IResult<&str, Type> {
     map(
         tuple((
-            keyword("data"),
+            keyword(DATA_KEYWORD),
             preceded(multispace0, identifier),
             preceded(multispace0, char(':')),
             many1(parse_adt_cons),
-            preceded(multispace0, keyword("end")),
+            preceded(multispace0, keyword(END_KEYWORD)),
         )),
         |(_, name, _, cons, _)| Type::Tadt(name.to_string(), cons),
     )(input)