added lambda expression parser

Author: Rafael-Sapienza

src/ir/ast.rs

@@ -116,6 +116,9 @@ pub enum Expression {
     IsNothing(Box<Expression>),
     Propagate(Box<Expression>),
 
+    //Lambda expression
+    Lambda(Function),
+
     // List value
     ListValue(Vec<Expression>),
 

src/parser/parser_common.rs

@@ -36,6 +36,8 @@ pub const ASSERT_KEYWORD: &str = "assert";
 pub const VAR_KEYWORD: &str = "var";
 pub const VAL_KEYWORD: &str = "val";
 pub const DEF_KEYWORD: &str = "def";
+pub const LAMBDA_KEYWORD: &str = "lambda";
+pub const RET_KEYWORD: &str = "return";
 
 // Operator and symbol constants
 pub const FUNCTION_ARROW: &str = "->";

src/parser/parser_expr.rs

@@ -1,7 +1,7 @@
 use nom::{
     branch::alt,
     bytes::complete::{tag, take_while},
-    character::complete::{char, digit1, multispace0},
+    character::complete::{char, digit1, multispace0, multispace1},
     combinator::{map, map_res, opt, value, verify},
     error::Error,
     multi::{fold_many0, separated_list0},
@@ -11,19 +11,26 @@ use nom::{
 
 use std::str::FromStr;
 
-use crate::ir::ast::Expression;
+use crate::{ir::ast::Expression, parser::{parser_common::END_KEYWORD}};
 use crate::parser::parser_common::{
     identifier,
     is_string_char,
     keyword,
     // Other character constants
     COMMA_CHAR,
+    COLON_CHAR,
     // Bracket and parentheses constants
     LEFT_BRACKET,
     LEFT_PAREN,
     RIGHT_BRACKET,
     RIGHT_PAREN,
+    FUNCTION_ARROW,
+    LAMBDA_KEYWORD,
 };
+use crate::parser::parser_stmt::{parse_formal_argument, parse_return_statement};
+use crate::parser::parser_type::parse_type;
+use crate::ir::ast::Function;
+use crate::ir::ast::Statement;
 
 pub fn parse_expression(input: &str) -> IResult<&str, Expression> {
     parse_or(input)
@@ -117,6 +124,7 @@ fn parse_factor(input: &str) -> IResult<&str, Expression> {
         parse_list,
         parse_function_call,
         parse_var,
+        parse_lambda,
         delimited(
             char::<&str, Error<&str>>(LEFT_PAREN),
             parse_expression,
@@ -125,6 +133,39 @@ fn parse_factor(input: &str) -> IResult<&str, Expression> {
     ))(input)
 }
 
+fn parse_lambda(input: &str) -> IResult<&str, Expression> {
+    map(
+        tuple((
+            keyword(LAMBDA_KEYWORD),
+            preceded(multispace1, identifier),
+            delimited(
+                char::<&str, Error<&str>>(LEFT_PAREN),
+                separated_list0(
+                    tuple((
+                        multispace0,
+                        char::<&str, Error<&str>>(COMMA_CHAR),
+                        multispace0,
+                    )),
+                    parse_formal_argument,
+                ),
+                char::<&str, Error<&str>>(RIGHT_PAREN),
+            ),
+            preceded(multispace0, tag(FUNCTION_ARROW)),
+            delimited(multispace0, parse_type, char::<&str, Error<&str>>(COLON_CHAR)),
+            parse_return_statement, 
+            keyword(END_KEYWORD)
+        )),
+        |(_, name, args, _, t, return_stmt, _)| {
+            Expression::Lambda(Function {
+                name: name.to_string(),
+                kind: t,
+                params: args,
+                body: Some(Box::new(Statement::Block(vec![return_stmt]))),
+            })
+        },
+    )(input)
+}
+
 fn parse_bool(input: &str) -> IResult<&str, Expression> {
     alt((
         value(Expression::CTrue, keyword("True")),

src/parser/parser_stmt.rs

@@ -13,7 +13,7 @@ use crate::ir::ast::{FormalArgument, Function, Statement};
 use crate::parser::parser_common::{
     identifier, keyword, ASSERT_KEYWORD, COLON_CHAR, COMMA_CHAR, DEF_KEYWORD, ELSE_KEYWORD,
     END_KEYWORD, EQUALS_CHAR, FOR_KEYWORD, FUNCTION_ARROW, IF_KEYWORD, IN_KEYWORD, LEFT_PAREN,
-    RIGHT_PAREN, SEMICOLON_CHAR, VAL_KEYWORD, VAR_KEYWORD, WHILE_KEYWORD,
+    RIGHT_PAREN, SEMICOLON_CHAR, VAL_KEYWORD, VAR_KEYWORD, WHILE_KEYWORD, RET_KEYWORD
 };
 use crate::parser::parser_expr::parse_expression;
 use crate::parser::parser_type::parse_type;
@@ -28,9 +28,21 @@ pub fn parse_statement(input: &str) -> IResult<&str, Statement> {
         parse_for_statement,
         parse_assert_statement,
         parse_function_definition_statement,
+        parse_return_statement,
     ))(input)
 }
 
+pub fn parse_return_statement(input: &str) -> IResult<&str, Statement> {
+    map(
+        tuple((
+            keyword(RET_KEYWORD),
+            multispace0,
+            parse_expression,
+        )),
+        |(_, _, expr)| Statement::Return(Box::new(expr)),
+    )(input)
+}
+
 fn parse_var_declaration_statement(input: &str) -> IResult<&str, Statement> {
     map(
         tuple((
@@ -181,7 +193,7 @@ fn parse_function_definition_statement(input: &str) -> IResult<&str, Statement>
     )(input)
 }
 
-fn parse_block(input: &str) -> IResult<&str, Statement> {
+pub fn parse_block(input: &str) -> IResult<&str, Statement> {
     map(
         tuple((
             char::<&str, Error<&str>>(COLON_CHAR),
@@ -204,7 +216,7 @@ fn parse_block(input: &str) -> IResult<&str, Statement> {
     )(input)
 }
 
-fn parse_formal_argument(input: &str) -> IResult<&str, FormalArgument> {
+pub fn parse_formal_argument(input: &str) -> IResult<&str, FormalArgument> {
     map(
         tuple((
             preceded(multispace0, identifier),