feat: append, concat and pop can be used as values

Author: SuperFola

.gitignore

@@ -14,6 +14,7 @@ __arkscript__/
 /*.ark
 *.ark.ir
 !tests/unittests/resources/BytecodeReaderSuite/*.arkc
+tools/*_hash.py
 
 # Generated files
 include/Ark/Constants.hpp

CHANGELOG.md

@@ -7,9 +7,11 @@
 
 ### Added
 - added new macro `$gensym`, to generate a unique symbol identifier to use in macros
+- `append`, `concat`, and `pop` can be use as values
 
 ### Changed
 - all paths inside `if` should return a value, when used as an expression. If an `else` branch is missing, `nil` will be returned
+- new compile time error when trying to use `append!`, `concat!`, `pop!`, `@=` and `@@=` as values
 
 ### Removed
 

include/Ark/Builtins/Builtins.hpp

@@ -163,6 +163,9 @@ namespace Ark::internal::Builtins
         ARK_BUILTIN(at);
         ARK_BUILTIN(atAt);
         ARK_BUILTIN(type);
+        ARK_BUILTIN(append_list);
+        ARK_BUILTIN(concat_list);
+        ARK_BUILTIN(pop_list);
     }
 }
 

src/arkreactor/Builtins/Builtins.cpp

@@ -134,6 +134,9 @@ namespace Ark::internal::Builtins
         { "head", Value(Operators::head) },
         { "@", Value(Operators::at) },
         { "@@", Value(Operators::atAt) },
-        { "type", Value(Operators::type) }
+        { "type", Value(Operators::type) },
+        { "append", Value(Operators::append_list) },
+        { "concat", Value(Operators::concat_list) },
+        { "pop", Value(Operators::pop_list) }
     };
 }

src/arkreactor/Builtins/Operators.cpp

@@ -374,4 +374,70 @@ namespace Ark::internal::Builtins::Operators
 
         return Value(std::to_string(n[0].valueType()));
     }
+
+    // cppcheck-suppress constParameterReference
+    Value append_list(std::vector<Value>& n, VM* vm [[maybe_unused]])
+    {
+        if (n.size() < 2 || n[0].valueType() != ValueType::List)
+            throw types::TypeCheckingError(
+                "append",
+                { { types::Contract {
+                    { types::Typedef("list", ValueType::List),
+                      types::Typedef("value", ValueType::Any, /* is_variadic= */ true) } } } },
+                n);
+
+        for (Value& e : n | std::ranges::views::drop(1))
+            n[0].list().push_back(e);
+
+        return n[0];
+    }
+
+    // cppcheck-suppress constParameterReference
+    Value concat_list(std::vector<Value>& n, VM* vm [[maybe_unused]])
+    {
+        if (n.size() < 2 || n[0].valueType() != ValueType::List)
+            throw types::TypeCheckingError(
+                "concat",
+                { { types::Contract {
+                    { types::Typedef("list", ValueType::List),
+                      types::Typedef("value", ValueType::List, /* is_variadic= */ true) } } } },
+                n);
+
+        for (Value& e : n | std::ranges::views::drop(1))
+        {
+            if (e.valueType() != ValueType::List)
+                throw types::TypeCheckingError(
+                    "concat",
+                    { { types::Contract {
+                        { types::Typedef("dst", ValueType::List),
+                          types::Typedef("src", ValueType::List, /* is_variadic= */ true) } } } },
+                    n);
+
+            std::ranges::copy(e.list(), std::back_inserter(n[0].list()));
+        }
+
+        return n[0];
+    }
+
+    // cppcheck-suppress constParameterReference
+    Value pop_list(std::vector<Value>& n, VM* vm [[maybe_unused]])
+    {
+        if (!types::check(n, ValueType::List, ValueType::Number))
+            throw types::TypeCheckingError(
+                "pop",
+                { { types::Contract {
+                    { types::Typedef("list", ValueType::List),
+                      types::Typedef("index", ValueType::Number) } } } },
+                n);
+
+        long idx = static_cast<long>(n[1].number());
+        idx = idx < 0 ? static_cast<long>(n[0].list().size()) + idx : idx;
+        if (std::cmp_greater_equal(idx, n[0].list().size()) || idx < 0)
+            VM::throwVMError(
+                ErrorKind::Index,
+                fmt::format("pop index ({}) out of range (list size: {})", idx, n[0].list().size()));
+
+        n[0].list().erase(n[0].list().begin() + idx);
+        return n[0];
+    }
 }

src/arkreactor/Compiler/Lowerer/ASTLowerer.cpp

@@ -320,6 +320,10 @@ namespace Ark::internal
 
         if (const auto it_builtin = getBuiltin(name))
             page(p).emplace_back(Instruction::BUILTIN, it_builtin.value());
+        else if (std::ranges::find(Language::UpdateRef, name) != Language::UpdateRef.end())
+            buildAndThrowError(fmt::format("`{}' updates a list in-place, and can not be used as a value. Prefer using their copy alternative (without the `!` at the end) when possible", name), x);
+        else if (name == Language::And || name == Language::Or)
+            buildAndThrowError(fmt::format("`{}' can not be used as a value like `+', where (let add +) (add 1 2) would be valid", name), x);
         else if (getOperator(name).has_value())
             buildAndThrowError(fmt::format("Found a freestanding operator: `{}`. It can not be used as value like `+', where (let add +) (add 1 2) would be valid", name), x);
         else

tests/unittests/resources/DiagnosticsSuite/compileTime/let_a_and.ark

@@ -0,0 +1,2 @@
+(let a and)
+(a 1 2)

tests/unittests/resources/DiagnosticsSuite/compileTime/let_a_and.expected

@@ -0,0 +1,6 @@
+In file tests/unittests/resources/DiagnosticsSuite/compileTime/let_a_and.ark:1
+    1 | (let a and)
+      |        ^~~
+    2 | (a 1 2)
+    3 |
+        `and' can not be used as a value like `+', where (let add +) (add 1 2) would be valid

tests/unittests/resources/DiagnosticsSuite/compileTime/let_a_append_in_place.ark

@@ -0,0 +1,3 @@
+(let a append!)
+(mut b [])
+(a b 5)

tests/unittests/resources/DiagnosticsSuite/compileTime/let_a_append_in_place.expected

@@ -0,0 +1,6 @@
+In file tests/unittests/resources/DiagnosticsSuite/compileTime/let_a_append_in_place.ark:1
+    1 | (let a append!)
+      |        ^~~~~~~
+    2 | (mut b [])
+    3 | (a b 5)
+        `append!' updates a list in-place, and can not be used as a value. Prefer using their copy alternative (without the `!` at the end) when possible