5 files changed, 180 insertions, 27 deletions

diff --git a/src/errors.c b/src/errors.c
index e69e4f9..b93b462 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -8,6 +8,13 @@ static const char* error_msgs[] = {
     [ERR_MALFORMED_NUMBER] = "error: malformed number token",
     [ERR_MALFORMED_EXPR]   = "error: malformed expression",
     [ERR_UNIMPLEMENTED]    = "error: not implemented",
+    [ERR_NOT_A_NUMBER]     = "error: expected a number",
+    [ERR_NOT_A_SYMBOL]     = "error: expected a symbol",
+    [ERR_NOT_A_STRING]     = "error: expected a string",
+    [ERR_NOT_A_TYPE]       = "error: expected a type",
+    [ERR_NOT_A_BOOL]       = "error: expected a bool",
+    [ERR_NOT_A_LPAREN]     = "error: expected opening parentheses (lparen)",
+    [ERR_NOT_A_RPAREN]     = "error: expected closing parentheses (rparen)",
 };
 
 static Error current_error = {.value = ERR_OK};
diff --git a/src/errors.h b/src/errors.h
index 25f9945..871711b 100644
--- a/src/errors.h
+++ b/src/errors.h
@@ -16,6 +16,13 @@ typedef enum ErrorValue {
     ERR_MALFORMED_NUMBER,
     ERR_MALFORMED_EXPR,
     ERR_UNIMPLEMENTED,
+    ERR_NOT_A_NUMBER,
+    ERR_NOT_A_SYMBOL,
+    ERR_NOT_A_STRING,
+    ERR_NOT_A_TYPE,
+    ERR_NOT_A_BOOL,
+    ERR_NOT_A_LPAREN,
+    ERR_NOT_A_RPAREN,
     ERR_OK,
 } ErrorValue;
 
diff --git a/src/nodes.c b/src/nodes.c
index 855d186..fc39d8e 100644
--- a/src/nodes.c
+++ b/src/nodes.c
@@ -23,6 +23,7 @@ print_node(Node *node) {
             }
         } break;
         case NODE_SYMBOL:
+        case NODE_TYPE:
         case NODE_STRING: {
             sv_write(&node->string);
         } break;
@@ -51,7 +52,7 @@ print_node(Node *node) {
             printf("(def ");
             print_node(node->def.symbol);
             printf(":");
-            sv_write(&node->def.type);
+            print_node(node->def.type);
             printf(" ");
             print_node(node->def.value);
             printf(")");
@@ -63,6 +64,31 @@ print_node(Node *node) {
             print_node(node->def.value);
             printf(")");
         } break;
+        case NODE_FUN: {
+            printf("(fun ");
+            print_node(node->fun.name);
+            printf(" (");
+            size_t n_params = array_size(node->fun.param_names);
+            for (size_t i = 0; i < n_params; ++i) {
+                print_node(node->fun.param_names[i]);
+                printf(":");
+                print_node(node->fun.param_types[i]);
+                if (i < n_params - 1) {
+                    printf(" ");
+                }
+            }
+            printf(")");
+            printf(": ");
+            print_node(node->fun.return_type);
+
+            size_t n_expr = array_size(node->fun.body);
+            for (size_t i = 0; i < n_expr; ++i) {
+                printf(" ");
+                print_node(node->fun.body[i]);
+            }
+
+            printf(")");
+        } break;
         default: { printf("{#unknown#}"); } break;
     }
 }
diff --git a/src/nodes.h b/src/nodes.h
index 566d6d3..2e24ea5 100644
--- a/src/nodes.h
+++ b/src/nodes.h
@@ -7,8 +7,10 @@ typedef enum NodeType {
     NODE_BOOL,
     NODE_STRING,
     NODE_SYMBOL,
+    NODE_TYPE,
     NODE_DEF,
     NODE_SET,
+    NODE_FUN,
 } NodeType;
 
 typedef struct Node {
@@ -38,13 +40,23 @@ typedef struct Node {
         struct {
             struct Node *symbol;
             struct Node *value;
-            StringView type;
+            struct Node *type;
         } def;
 
+        // Variable assignment.
         struct {
             struct Node *symbol;
             struct Node *value;
         } set;
+
+        // Function definition.
+        struct {
+            struct Node *name;
+            struct Node **param_names;
+            struct Node **param_types;
+            struct Node *return_type;
+            struct Node **body;
+        } fun;
     };
 } Node;
 
diff --git a/src/parser.c b/src/parser.c
index b36ddc9..cfbefaf 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -16,9 +16,33 @@ has_next(Parser *parser) {
     return parser->current < array_size(parser->tokens);
 }
 
+bool
+consume_rparen(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_RPAREN) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_RPAREN, tok.line, tok.col);
+        return false;
+    }
+    return true;
+}
+
+bool
+consume_lparen(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_LPAREN) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_LPAREN, tok.line, tok.col);
+        return false;
+    }
+    return true;
+}
+
 Node *
 parse_number(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_NUMBER) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_NUMBER, tok.line, tok.col);
+        return NULL;
+    }
 
     bool negative = false;
     int base = 10;
@@ -93,6 +117,10 @@ parse_number(Parser *parser) {
 Node *
 parse_string(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_STRING) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_STRING, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_STRING);
     node->string = tok.value;
     return node;
@@ -101,14 +129,39 @@ parse_string(Parser *parser) {
 Node *
 parse_symbol(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_SYMBOL) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_SYMBOL, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_SYMBOL);
     node->string = tok.value;
     return node;
 }
 
 Node *
+parse_type(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_COLON) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_TYPE, tok.line, tok.col);
+        return NULL;
+    }
+    tok = next_token(parser);
+    if (tok.type != TOKEN_SYMBOL) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_TYPE, tok.line, tok.col);
+        return NULL;
+    }
+    Node *node = alloc_node(NODE_TYPE);
+    node->string = tok.value;
+    return node;
+}
+
+Node *
 parse_bool(Parser *parser) {
     Token tok = next_token(parser);
+    if (!(tok.type == TOKEN_TRUE || tok.type == TOKEN_FALSE)) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_BOOL, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_BOOL);
     node->boolean = tok.type == TOKEN_TRUE;
     return node;
@@ -138,63 +191,51 @@ parse_builtin(Parser *parser) {
 
 Node *
 parse_def(Parser *parser) {
-    Token op = next_token(parser);
-    Node *symbol = parse_next(parser);
-    if (symbol == NULL || symbol->type != NODE_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    next_token(parser); // Skip keyword.
+
+    Node *symbol = parse_symbol(parser);
+    if (symbol == NULL) {
         return NULL;
     }
 
     // TODO: Making type checking mandatory for now until we introduce
     // type inference.
-    Token next = next_token(parser);
-    if (next.type != TOKEN_COLON) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
-        return NULL;
-    }
-    Token type_name = next_token(parser);
-    if (type_name.type != TOKEN_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    Node *type = parse_type(parser);
+    if (type == NULL) {
         return NULL;
     }
 
     Node *value = parse_next(parser);
     if (value == NULL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
         return NULL;
     }
 
-    Token end = next_token(parser);
-    if (end.type != TOKEN_RPAREN) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    if (!consume_rparen(parser)) {
         return NULL;
     }
 
     Node *node = alloc_node(NODE_DEF);
     node->def.symbol = symbol;
     node->def.value = value;
-    node->def.type = type_name.value;
+    node->def.type = type;
     return node;
 }
 
 Node *
 parse_set(Parser *parser) {
-    Token op = next_token(parser);
-    Node *symbol = parse_next(parser);
-    if (symbol == NULL || symbol->type != NODE_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    next_token(parser); // Skip keyword.
+
+    Node *symbol = parse_symbol(parser);
+    if (symbol == NULL) {
         return NULL;
     }
 
     Node *value = parse_next(parser);
     if (value == NULL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
         return NULL;
     }
 
-    Token end = next_token(parser);
-    if (end.type != TOKEN_RPAREN) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    if (!consume_rparen(parser)) {
         return NULL;
     }
 
@@ -205,6 +246,65 @@ parse_set(Parser *parser) {
 }
 
 Node *
+parse_fun(Parser *parser) {
+    next_token(parser); // Skip keyword.
+
+    Node *name = parse_symbol(parser);
+    if (name == NULL) {
+        return NULL;
+    }
+
+    Node *node = alloc_node(NODE_FUN);
+    node->fun.name = name;
+    array_init(node->fun.param_names, 0);
+    array_init(node->fun.param_types, 0);
+    array_init(node->fun.body, 0);
+
+    // Parse parameter list and return type.
+    if (!consume_lparen(parser)) {
+        return NULL;
+    }
+    while (true) {
+        Token next = peek_token(parser);
+        if (next.type == TOKEN_RPAREN) {
+            next_token(parser);
+            break;
+        }
+        Node *name = parse_symbol(parser);
+        if (name == NULL) {
+            return NULL;
+        }
+        Node *type = parse_type(parser);
+        if (type == NULL) {
+            return NULL;
+        }
+        array_push(node->fun.param_names, name);
+        array_push(node->fun.param_types, type);
+    }
+    Node *ret_type = parse_type(parser);
+    if (ret_type == NULL) {
+        return NULL;
+    }
+    node->fun.return_type = ret_type;
+
+    // Parse body.
+    while (true) {
+        Token next = peek_token(parser);
+        if (next.type == TOKEN_RPAREN) {
+            next_token(parser);
+            break;
+        }
+        Node *expr = parse_next(parser);
+        if (expr == NULL) {
+            return NULL;
+        }
+        array_push(node->fun.body, expr);
+    }
+
+    return node;
+}
+
+Node *
 parse_paren(Parser *parser) {
     next_token(parser); // Skip paren.
     Token tok = peek_token(parser);
@@ -222,6 +322,7 @@ parse_paren(Parser *parser) {
         // Special functions.
         case TOKEN_DEF: { return parse_def(parser); } break;
         case TOKEN_SET: { return parse_set(parser); } break;
+        case TOKEN_FUN: { return parse_fun(parser); } break;
         default: break;
     }