add anonymous functions

src/main.c

@@ -428,7 +428,7 @@ Translated load_argon_file(char *path, ArErr *err) {
   hashmap_free(translated.constants.hashmap, NULL);
   Translated gc_translated = {
       translated.registerCount, NULL, {}, {}, translated.path};
-  gc_translated.bytecode.data = ar_alloc(translated.bytecode.capacity);
+  gc_translated.bytecode.data = ar_alloc_atomic(translated.bytecode.capacity);
   memcpy(gc_translated.bytecode.data, translated.bytecode.data,
          translated.bytecode.capacity);
   gc_translated.bytecode.element_size = translated.bytecode.element_size;
@@ -436,7 +436,7 @@ Translated load_argon_file(char *path, ArErr *err) {
   gc_translated.bytecode.resizable = false;
   gc_translated.bytecode.capacity =
       translated.bytecode.size * translated.bytecode.element_size;
-  gc_translated.constants.data = ar_alloc(translated.constants.capacity);
+  gc_translated.constants.data = ar_alloc_atomic(translated.constants.capacity);
   memcpy(gc_translated.constants.data, translated.constants.data,
          translated.constants.capacity);
   gc_translated.constants.size = translated.constants.size;

src/parser/parentheses-and-anonymous-function/parentheses-and-anonymous-function.c

@@ -0,0 +1,96 @@
+#include "parentheses-and-anonymous-function.h"
+#include "../assignable/identifier/identifier.h"
+#include "../function/function.h"
+#include "../../memory.h"
+#include <stddef.h>
+#include <string.h>
+
+ParsedValueReturn parse_parentheses(char *file, DArray *tokens, size_t *index) {
+  (*index)++;
+  skip_newlines_and_indents(tokens, index);
+  ArErr err = error_if_finished(file, tokens, index);
+  if (err.exists) {
+    // darray_free(&list, free_parsed);
+    return (ParsedValueReturn){err, NULL};
+  }
+  DArray list;
+  darray_init(&list, sizeof(ParsedValue));
+  Token *token = darray_get(tokens, *index);
+  if (token->type != TOKEN_RPAREN) {
+    while (*index < tokens->size) {
+      ParsedValueReturn parsedItem = parse_token(file, tokens, index, true);
+      if (parsedItem.err.exists) {
+        darray_free(&list, free_parsed);
+        return parsedItem;
+      }
+      darray_push(&list, parsedItem.value);
+      free(parsedItem.value);
+      skip_newlines_and_indents(tokens, index);
+      ArErr err = error_if_finished(file, tokens, index);
+      if (err.exists) {
+        darray_free(&list, free_parsed);
+        return (ParsedValueReturn){err, NULL};
+      }
+      token = darray_get(tokens, *index);
+      if (token->type == TOKEN_RPAREN) {
+        break;
+      } else if (token->type != TOKEN_COMMA) {
+        darray_free(&list, free_parsed);
+        return (ParsedValueReturn){create_err(token->line, token->column,
+                                              token->length, file,
+                                              "Syntax Error", "expected comma"),
+                                   NULL};
+      }
+      skip_newlines_and_indents(tokens, index);
+      err = error_if_finished(file, tokens, index);
+      if (err.exists) {
+        darray_free(&list, free_parsed);
+        return (ParsedValueReturn){err, NULL};
+      }
+    }
+  }
+  (*index)++;
+  if (*index < tokens->size) {
+    token = darray_get(tokens, *index);
+    if (token->type == TOKEN_ASSIGN) {
+      (*index)++;
+      ArErr err = error_if_finished(file, tokens, index);
+      if (err.exists) {
+        darray_free(&list, free_parsed);
+        return (ParsedValueReturn){err, NULL};
+      }
+      DArray parameters;
+      darray_init(&parameters, sizeof(char *));
+      for (size_t i = 0; i < list.size; i++) {
+        ParsedValue *item = darray_get(&list, i);
+        if (item->type != AST_IDENTIFIER) {
+          return (ParsedValueReturn){
+              create_err(token->line, token->column, token->length, file,
+                         "Syntax Error", "expected identifier"),
+              NULL};
+        }
+        char *param = strdup(((ParsedIdentifier *)item->data)->name);
+        darray_push(&parameters, &param);
+      }
+      darray_free(&list, free_parsed);
+      ParsedValueReturn parsedBody = parse_token(file, tokens, index, true);
+      if (parsedBody.err.exists) {
+        darray_free(&parameters, free_parameter);
+        return parsedBody;
+      }
+      return (ParsedValueReturn){
+          no_err,
+          create_parsed_function("anonymous", parameters, parsedBody.value)};
+    }
+  }
+  if (list.size != 1) {
+    return (ParsedValueReturn){create_err(token->line, token->column,
+                                          token->length, file, "Syntax Error",
+                                          "expected 1 body"),
+                               NULL};
+  }
+  ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
+  memcpy(parsedValue, darray_get(&list, 0), sizeof(ParsedValue));
+  darray_free(&list, NULL);
+  return (ParsedValueReturn){no_err, parsedValue};
+}

src/parser/parentheses-and-anonymous-function/parentheses-and-anonymous-function.h

@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#ifndef parentheses_and_anonymous_function_H
+#define parentheses_and_anonymous_function_H
+#include "../parser.h"
+#include "../../lexer/token.h"
+
+ParsedValueReturn parse_parentheses(char *file, DArray *tokens, size_t *index);
+
+#endif // parentheses_and_anonymous_function_H

src/parser/parser.c

@@ -13,6 +13,7 @@
 #include "assignable/identifier/identifier.h"
 #include "declaration/declaration.h"
 #include "dictionary/dictionary.h"
+#include "parentheses-and-anonymous-function/parentheses-and-anonymous-function.h"
 #include "dowrap/dowrap.h"
 #include "function/function.h"
 #include "if/if.h"
@@ -128,6 +129,9 @@ ParsedValueReturn parse_token_full(char *file, DArray *tokens, size_t *index,
   case TOKEN_LBRACKET:
     output = parse_list(file, tokens, index);
     break;
+  case TOKEN_LPAREN:
+    output = parse_parentheses(file, tokens, index);
+    break;
   case TOKEN_LBRACE:
     output = parse_dictionary(file, tokens, index);
     break;

src/runtime/objects/number/number.c

@@ -7,7 +7,6 @@
 #include "number.h"
 #include "../functions/functions.h"
 #include "../string/string.h"
-#include <gmp-x86_64.h>
 #include <gmp.h>
 #include <inttypes.h>
 #include <stdio.h>
@@ -360,7 +359,7 @@ void create_ARGON_NUMBER_TYPE() {
 void mpz_init_gc_managed(mpz_t z, size_t limbs_count) {
   z->_mp_alloc = limbs_count;
   z->_mp_size = 0;
-  z->_mp_d = ar_alloc(limbs_count * sizeof(mp_limb_t));
+  z->_mp_d = ar_alloc_atomic(limbs_count * sizeof(mp_limb_t));
 }
 
 void mpq_init_gc_managed(mpq_t q, size_t num_limbs, size_t den_limbs) {

testing.ar

@@ -5,11 +5,33 @@ let say_hi(name) = do
     do
         return name
     )
-    return "hello "+u+", how are you?"
 
-term.log(say_hi("william"))
+    return "hello "+u+", how are you?"
+term.log(say_hi("william")
+, say_hi)
 
 let a = 9
 let b = 10
-
 term.log(string(a)+'+'+string(b)+'='+string(a+b))
+
+
+let call(f) = do
+    term.log(f)
+
+    return f()
+
+
+term.log(
+call(
+()=call(
+()=call(
+()=call(
+()=do
+    term.log("hello this is a test of anonymous functions. hopefully this works :)")
+
+    return say_hi("test")
+)
+)
+)
+)
+)