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

@@ -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);
     }
 }
 

include/Ark/Builtins/Builtins.hpp

@@ -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/Builtins.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/Builtins/Operators.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

src/arkreactor/Compiler/Lowerer/ASTLowerer.cpp

@@ -23,4 +23,7 @@
   (head [])
   (@ [1 2] 1)
   (@@ [[1] [2] [3]] 0 0)
-  (type 12))
+  (type 12)
+  (append [] 1)
+  (concat [1] [2])
+  (pop [1] 0))

tests/unittests/resources/CompilerSuite/ir/operators.ark

@@ -66,7 +66,19 @@ page_0
 	AT_AT 0
 	LOAD_CONST 3
 	TYPE 0
-	CALL_BUILTIN 9, 22
+	LOAD_CONST 0
+	LIST 0
+	APPEND 1
+	LOAD_CONST 1
+	LIST 1
+	LOAD_CONST 0
+	LIST 1
+	CONCAT 1
+	LOAD_CONST 5
+	LOAD_CONST 0
+	LIST 1
+	POP_LIST 0
+	CALL_BUILTIN 9, 25
 .L0:
 	POP 0
 	HALT 0

tests/unittests/resources/CompilerSuite/ir/operators.expected

@@ -1 +1 @@
-(print + - * / mod toNumber toString < <= > >= = != not len empty? nil? tail head @ @@ type)
+(print + - * / mod toNumber toString < <= > >= = != not len empty? nil? tail head @ @@ type append concat pop)

tests/unittests/resources/CompilerSuite/ir/operators_as_builtins.ark

@@ -22,7 +22,10 @@ page_0
 	BUILTIN 88
 	BUILTIN 89
 	BUILTIN 90
-	CALL_BUILTIN 9, 22
+	BUILTIN 91
+	BUILTIN 92
+	BUILTIN 93
+	CALL_BUILTIN 9, 25
 .L0:
 	POP 0
 	HALT 0