diff --git a/src/language/ASTNode.hpp b/src/language/ASTNode.hpp
index 5e6706a436395ebb4f3e0295922c958af1f54d64..f0bbe392e69ac672444b943a3f17df414af02f3b 100644
--- a/src/language/ASTNode.hpp
+++ b/src/language/ASTNode.hpp
@@ -5,7 +5,7 @@
 #include <PugsMacros.hpp>
 
 #include <ASTNodeDataType.hpp>
-#include <ASTNodeDataVariant.hpp>
+#include <DataVariant.hpp>
 
 #include <node_processor/ExecutionPolicy.hpp>
 #include <node_processor/INodeProcessor.hpp>
@@ -31,7 +31,7 @@ struct ASTNode : public parse_tree::basic_node<ASTNode>
   }
 
   PUGS_INLINE
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     Assert(m_node_processor, "Undefined node processor");
diff --git a/src/language/CFunctionEmbedder.hpp b/src/language/CFunctionEmbedder.hpp
index 5434d4fa0db00ac9a6b2f4e4140545ab31b942aa..ced2817c4e27c9dcf7b77c4b14d31ea40c8ebe6b 100644
--- a/src/language/CFunctionEmbedder.hpp
+++ b/src/language/CFunctionEmbedder.hpp
@@ -5,7 +5,7 @@
 #include <PugsMacros.hpp>
 
 #include <ASTNodeDataType.hpp>
-#include <ASTNodeDataVariant.hpp>
+#include <DataVariant.hpp>
 
 #include <cmath>
 #include <functional>
@@ -24,7 +24,7 @@ class ICFunctionEmbedder
 
   virtual std::vector<ASTNodeDataType> getParameterDataTypes() const = 0;
 
-  virtual ASTNodeDataVariant apply(const std::vector<ASTNodeDataVariant>& x) const = 0;
+  virtual DataVariant apply(const std::vector<DataVariant>& x) const = 0;
 
   virtual ~ICFunctionEmbedder() = default;
 };
@@ -38,7 +38,7 @@ class CFunctionEmbedder : public ICFunctionEmbedder
 
   template <size_t I>
   PUGS_INLINE void
-  _copy_value(ArgsTuple& t, const std::vector<ASTNodeDataVariant>& v) const
+  _copy_value(ArgsTuple& t, const std::vector<DataVariant>& v) const
   {
     std::visit(
       [&](auto v_i) {
@@ -53,7 +53,7 @@ class CFunctionEmbedder : public ICFunctionEmbedder
 
   template <size_t... I>
   PUGS_INLINE void
-  _copy_from_vector(ArgsTuple& t, const std::vector<ASTNodeDataVariant>& v, std::index_sequence<I...>) const
+  _copy_from_vector(ArgsTuple& t, const std::vector<DataVariant>& v, std::index_sequence<I...>) const
   {
     Assert(sizeof...(Args) == v.size());
     (_copy_value<I>(t, v), ...);
@@ -99,8 +99,8 @@ class CFunctionEmbedder : public ICFunctionEmbedder
   }
 
   PUGS_INLINE
-  ASTNodeDataVariant
-  apply(const std::vector<ASTNodeDataVariant>& x) const final
+  DataVariant
+  apply(const std::vector<DataVariant>& x) const final
   {
     constexpr size_t N = std::tuple_size_v<ArgsTuple>;
     ArgsTuple t;
diff --git a/src/language/ASTNodeDataVariant.hpp b/src/language/DataVariant.hpp
similarity index 72%
rename from src/language/ASTNodeDataVariant.hpp
rename to src/language/DataVariant.hpp
index b2e4cbb25607fbfa0cd3dd1a0f5c5f3fdf899a03..d33dea2b236c4a5018d33fa746a4d556a317f18f 100644
--- a/src/language/ASTNodeDataVariant.hpp
+++ b/src/language/DataVariant.hpp
@@ -1,5 +1,5 @@
-#ifndef AST_NODE_DATA_VARIANT_HPP
-#define AST_NODE_DATA_VARIANT_HPP
+#ifndef DATA_VARIANT_HPP
+#define DATA_VARIANT_HPP
 
 #include <tuple>
 #include <variant>
@@ -9,16 +9,15 @@
 
 class AggregateDataVariant;
 
-using ASTNodeDataVariant =
-  std::variant<std::monostate, bool, uint64_t, int64_t, double, std::string, AggregateDataVariant>;
+using DataVariant = std::variant<std::monostate, bool, uint64_t, int64_t, double, std::string, AggregateDataVariant>;
 
 class AggregateDataVariant
 {
  private:
-  std::vector<ASTNodeDataVariant> m_data_vector;
+  std::vector<DataVariant> m_data_vector;
 
   std::ostream&
-  _printComponent(std::ostream& os, const ASTNodeDataVariant& value) const
+  _printComponent(std::ostream& os, const DataVariant& value) const
   {
     std::visit(
       [&](auto&& v) {
@@ -61,14 +60,14 @@ class AggregateDataVariant
   }
 
   PUGS_INLINE
-  ASTNodeDataVariant& operator[](size_t i)
+  DataVariant& operator[](size_t i)
   {
     Assert(i < m_data_vector.size());
     return m_data_vector[i];
   }
 
   PUGS_INLINE
-  const ASTNodeDataVariant& operator[](size_t i) const
+  const DataVariant& operator[](size_t i) const
   {
     Assert(i < m_data_vector.size());
     return m_data_vector[i];
@@ -77,7 +76,7 @@ class AggregateDataVariant
   AggregateDataVariant& operator=(const AggregateDataVariant&) = default;
   AggregateDataVariant& operator=(AggregateDataVariant&&) = default;
 
-  AggregateDataVariant(std::vector<ASTNodeDataVariant>&& data_vector) : m_data_vector(data_vector) {}
+  AggregateDataVariant(std::vector<DataVariant>&& data_vector) : m_data_vector(data_vector) {}
 
   AggregateDataVariant(const AggregateDataVariant&) = default;
   AggregateDataVariant(AggregateDataVariant&&)      = default;
@@ -85,4 +84,4 @@ class AggregateDataVariant
   AggregateDataVariant() = default;
 };
 
-#endif   // AST_NODE_DATA_VARIANT_HPP
+#endif   // DATA_VARIANT_HPP
diff --git a/src/language/FunctionTable.hpp b/src/language/FunctionTable.hpp
index 451e95aeb11ab0fa0958f505578dcf7e99e00770..f7a3c27fc38528b78f56a9ec3280258ac938b5e0 100644
--- a/src/language/FunctionTable.hpp
+++ b/src/language/FunctionTable.hpp
@@ -2,7 +2,7 @@
 #define FUNCTION_TABLE_HPP
 
 #include <ASTNodeDataType.hpp>
-#include <ASTNodeDataVariant.hpp>
+#include <DataVariant.hpp>
 
 #include <ASTNode.hpp>
 
diff --git a/src/language/SymbolTable.hpp b/src/language/SymbolTable.hpp
index 648f71c6e6554de888c4094976fc7b2c04ada900..c625d8a0cdf731d784955c0162a353eb11044c4b 100644
--- a/src/language/SymbolTable.hpp
+++ b/src/language/SymbolTable.hpp
@@ -4,7 +4,7 @@
 #include <PugsMacros.hpp>
 
 #include <ASTNodeDataType.hpp>
-#include <ASTNodeDataVariant.hpp>
+#include <DataVariant.hpp>
 
 #include <pegtl/position.hpp>
 
@@ -25,7 +25,7 @@ class SymbolTable
     bool m_is_initialized{false};
 
     ASTNodeDataType m_data_type{ASTNodeDataType::undefined_t};
-    ASTNodeDataVariant m_value;
+    DataVariant m_value;
 
    public:
     bool
diff --git a/src/language/node_processor/ASTNodeExpressionListProcessor.hpp b/src/language/node_processor/ASTNodeExpressionListProcessor.hpp
index 88703b838d47750f5f46d4931b1f896236702a8b..e2523b2be879f6af22ffbe989f2bc188037f5259 100644
--- a/src/language/node_processor/ASTNodeExpressionListProcessor.hpp
+++ b/src/language/node_processor/ASTNodeExpressionListProcessor.hpp
@@ -11,16 +11,16 @@ class ASTNodeExpressionListProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
-    std::vector<ASTNodeDataVariant> list_values;
+    std::vector<DataVariant> list_values;
     list_values.reserve(m_node.children.size());
     for (auto& child : m_node.children) {
       list_values.emplace_back(child->execute(exec_policy));
     }
 
-    return ASTNodeDataVariant{std::move(list_values)};
+    return DataVariant{std::move(list_values)};
   }
 
   ASTNodeExpressionListProcessor(ASTNode& node) : m_node{node} {}
diff --git a/src/language/node_processor/ASTNodeListProcessor.hpp b/src/language/node_processor/ASTNodeListProcessor.hpp
index 2303d3f2f14b4403f390fdf878648ce09f215655..0e39a73404940af580c453fbd1d95731d66025a7 100644
--- a/src/language/node_processor/ASTNodeListProcessor.hpp
+++ b/src/language/node_processor/ASTNodeListProcessor.hpp
@@ -9,7 +9,7 @@ class ASTNodeListProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     for (auto& child : m_node.children) {
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index cbb7c4e741aa25ddf5b024e0b195c93b4d52a56d..ef58ef32e01ab36037554ef703254bbfc0c12c16 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -54,7 +54,7 @@ struct AffOp<language::minuseq_op>
 
 struct IAffectationExecutor
 {
-  virtual void affect(ASTNodeDataVariant&& rhs) = 0;
+  virtual void affect(DataVariant&& rhs) = 0;
 
   virtual ~IAffectationExecutor() = default;
 };
@@ -63,7 +63,7 @@ template <typename OperatorT, typename ValueT, typename DataT>
 class AffectationExecutor final : public IAffectationExecutor
 {
  private:
-  ASTNodeDataVariant* m_lhs{nullptr};
+  DataVariant* m_lhs{nullptr};
 
   static inline const bool _is_defined{[] {
     if constexpr (std::is_same_v<std::decay_t<ValueT>, bool>) {
@@ -75,7 +75,7 @@ class AffectationExecutor final : public IAffectationExecutor
   }()};
 
  public:
-  AffectationExecutor(ASTNode& node, ASTNodeDataVariant* lhs) : m_lhs(lhs)
+  AffectationExecutor(ASTNode& node, DataVariant* lhs) : m_lhs(lhs)
   {
     if constexpr (not _is_defined) {
       throw parse_error("invalid operands to affectation expression", std::vector{node.begin()});
@@ -83,7 +83,7 @@ class AffectationExecutor final : public IAffectationExecutor
   }
 
   PUGS_INLINE void
-  affect(ASTNodeDataVariant&& rhs)
+  affect(DataVariant&& rhs)
   {
     if constexpr (_is_defined) {
       if constexpr (std::is_same_v<ValueT, std::string>) {
@@ -126,7 +126,7 @@ class AffectationProcessor final : public INodeProcessor
   std::unique_ptr<AffectationExecutorT> m_affectation_executor;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     m_affectation_executor->affect(m_node.children[1]->execute(exec_policy));
@@ -165,7 +165,7 @@ class ListAffectationProcessor final : public INodeProcessor
       std::make_unique<AffectationExecutor<OperatorT, ValueT, DataT>>(m_node, &i_symbol->attributes().value()));
   }
 
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     AggregateDataVariant children_values = std::get<AggregateDataVariant>(m_node.children[1]->execute(exec_policy));
diff --git a/src/language/node_processor/BinaryExpressionProcessor.hpp b/src/language/node_processor/BinaryExpressionProcessor.hpp
index c8561f61c338abda228616c39329a55123856d97..f767bad1128e0c66e007336a9f315e8679fa98b9 100644
--- a/src/language/node_processor/BinaryExpressionProcessor.hpp
+++ b/src/language/node_processor/BinaryExpressionProcessor.hpp
@@ -156,8 +156,8 @@ class BinaryExpressionProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
 
-  PUGS_INLINE ASTNodeDataVariant
-  _eval(const ASTNodeDataVariant& a, const ASTNodeDataVariant& b)
+  PUGS_INLINE DataVariant
+  _eval(const DataVariant& a, const DataVariant& b)
   {
     // Add 'signed' when necessary to avoid signed/unsigned comparison warnings
     if constexpr ((not(std::is_same_v<A_DataT, bool> or std::is_same_v<B_DataT, bool>)) and
@@ -195,7 +195,7 @@ class BinaryExpressionProcessor final : public INodeProcessor
   }()};
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     if constexpr (_is_defined) {
diff --git a/src/language/node_processor/BreakProcessor.hpp b/src/language/node_processor/BreakProcessor.hpp
index 292184271ef45e3a250e9879b2e65416f3f8dc79..edf218d487660e80a8efe636dce9d4c0f577199c 100644
--- a/src/language/node_processor/BreakProcessor.hpp
+++ b/src/language/node_processor/BreakProcessor.hpp
@@ -6,7 +6,7 @@
 class BreakProcessor final : public INodeProcessor
 {
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     exec_policy = ExecutionPolicy(ExecutionPolicy::JumpType::break_jump, exec_policy.sharedContext());
diff --git a/src/language/node_processor/CFunctionProcessor.hpp b/src/language/node_processor/CFunctionProcessor.hpp
index 55354f78828f65531b27d1b5f8b1f94635ad2410..c7bdbad51df4b0b993261a8ad2304daccff93ca1 100644
--- a/src/language/node_processor/CFunctionProcessor.hpp
+++ b/src/language/node_processor/CFunctionProcessor.hpp
@@ -14,7 +14,7 @@ class CFunctionArgumentProcessor final : public INodeProcessor
   ASTNode& m_provided_value_node;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) {
@@ -33,7 +33,7 @@ class CFunctionExpressionProcessor final : public INodeProcessor
   std::shared_ptr<ICFunctionEmbedder> m_embedded_c_function;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     return m_embedded_c_function->apply(exec_policy.context());
@@ -64,7 +64,7 @@ class CFunctionProcessor : public INodeProcessor
     m_function_expression_processor = std::move(function_processor);
   }
 
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     ExecutionPolicy context_exec_policy{exec_policy.jumpType(),
diff --git a/src/language/node_processor/ConcatExpressionProcessor.hpp b/src/language/node_processor/ConcatExpressionProcessor.hpp
index 5f493b8d664b1f4515bac1cfa069b5d99ea8a531..d1f40b4c43bbd9b61e7e95b1b55ed7cf7d77d2cc 100644
--- a/src/language/node_processor/ConcatExpressionProcessor.hpp
+++ b/src/language/node_processor/ConcatExpressionProcessor.hpp
@@ -10,8 +10,8 @@ class ConcatExpressionProcessor final : public INodeProcessor
   ASTNode& m_node;
 
   PUGS_INLINE
-  ASTNodeDataVariant
-  _eval(const std::string& a, const ASTNodeDataVariant& b)
+  DataVariant
+  _eval(const std::string& a, const DataVariant& b)
   {
     if constexpr (std::is_same_v<B_DataT, std::string>) {
       return a + std::get<B_DataT>(b);
@@ -21,7 +21,7 @@ class ConcatExpressionProcessor final : public INodeProcessor
   }
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     return this->_eval(std::get<std::string>(m_node.children[0]->execute(exec_policy)),
diff --git a/src/language/node_processor/ContinueProcessor.hpp b/src/language/node_processor/ContinueProcessor.hpp
index 29cd31a4770d6677180fa9f0a5ad7766f6fac910..0b100e24816dcc74ba06ba468fcf5683a85f9487 100644
--- a/src/language/node_processor/ContinueProcessor.hpp
+++ b/src/language/node_processor/ContinueProcessor.hpp
@@ -6,7 +6,7 @@
 class ContinueProcessor final : public INodeProcessor
 {
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     exec_policy = ExecutionPolicy(ExecutionPolicy::JumpType::continue_jump, exec_policy.sharedContext());
diff --git a/src/language/node_processor/DoWhileProcessor.hpp b/src/language/node_processor/DoWhileProcessor.hpp
index a9c8a200569211fee293630a8dbf1def1385d472..d43d84fc3cc92c0795d523305b5d7c414d4b5a22 100644
--- a/src/language/node_processor/DoWhileProcessor.hpp
+++ b/src/language/node_processor/DoWhileProcessor.hpp
@@ -9,7 +9,7 @@ class DoWhileProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     bool continuation_test = true;
diff --git a/src/language/node_processor/ExecutionPolicy.hpp b/src/language/node_processor/ExecutionPolicy.hpp
index 3374a694c0d4051150583c5fd861137c24d5146f..0d5349ee07db6739f865021d51a5993f70d903e3 100644
--- a/src/language/node_processor/ExecutionPolicy.hpp
+++ b/src/language/node_processor/ExecutionPolicy.hpp
@@ -3,7 +3,7 @@
 
 #include <PugsMacros.hpp>
 
-#include <ASTNodeDataVariant.hpp>
+#include <DataVariant.hpp>
 
 #include <memory>
 #include <vector>
@@ -18,7 +18,7 @@ class ExecutionPolicy
     continue_jump
   };
 
-  using Context       = std::vector<ASTNodeDataVariant>;
+  using Context       = std::vector<DataVariant>;
   using SharedContext = std::shared_ptr<Context>;
 
  private:
diff --git a/src/language/node_processor/FakeProcessor.hpp b/src/language/node_processor/FakeProcessor.hpp
index a93af47de772c0ba3da421b6e42abe72c9c33ae4..3c4df3c9bf97ab09234dca02ac565d09f584da9b 100644
--- a/src/language/node_processor/FakeProcessor.hpp
+++ b/src/language/node_processor/FakeProcessor.hpp
@@ -6,7 +6,7 @@
 class FakeProcessor final : public INodeProcessor
 {
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy&)
   {
     return {};
diff --git a/src/language/node_processor/ForProcessor.hpp b/src/language/node_processor/ForProcessor.hpp
index 09362e7fa9110cd5da5843b1629d4d202b594b96..e69b34c72843aeee2fc745a7c46b05564fab3442 100644
--- a/src/language/node_processor/ForProcessor.hpp
+++ b/src/language/node_processor/ForProcessor.hpp
@@ -9,7 +9,7 @@ class ForProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     ExecutionPolicy exec_until_jump;
diff --git a/src/language/node_processor/FunctionProcessor.hpp b/src/language/node_processor/FunctionProcessor.hpp
index e2759e260498ac5fc9bc2758facb2e09b95f9ce5..572e25d291f9808ef59182ac8a096403c93440ea 100644
--- a/src/language/node_processor/FunctionProcessor.hpp
+++ b/src/language/node_processor/FunctionProcessor.hpp
@@ -16,7 +16,7 @@ class FunctionArgumentProcessor final : public INodeProcessor
   ASTNode& m_provided_value_node;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     ;
@@ -45,7 +45,7 @@ class FunctionExpressionProcessor final : public INodeProcessor
   ASTNode& m_function_expression;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     if constexpr (std::is_same_v<ReturnType, ExpressionValueType>) {
@@ -83,7 +83,7 @@ class FunctionProcessor : public INodeProcessor
     m_function_expression_processors.emplace_back(std::move(function_processor));
   }
 
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     ExecutionPolicy context_exec_policy{exec_policy.jumpType(),
@@ -93,15 +93,16 @@ class FunctionProcessor : public INodeProcessor
       argument_processor->execute(context_exec_policy);
     }
 
-#warning ugly: should define special case for multi-valued functions
     if (m_function_expression_processors.size() == 1) {
       return m_function_expression_processors[0]->execute(context_exec_policy);
     } else {
+      std::vector<DataVariant> list_values;
+      list_values.reserve(m_function_expression_processors.size());
+
       for (auto& function_expression_processor : m_function_expression_processors) {
-        function_expression_processor->execute(context_exec_policy);
+        list_values.emplace_back(function_expression_processor->execute(context_exec_policy));
       }
-#warning incorrect return value
-      return {};
+      return DataVariant{std::move(list_values)};
     }
   }
 
diff --git a/src/language/node_processor/INodeProcessor.hpp b/src/language/node_processor/INodeProcessor.hpp
index 90317538397c689416c3bbbcdd8c9b0186daf6f4..2afda896523174c21826665c059a754f6d7a8fbb 100644
--- a/src/language/node_processor/INodeProcessor.hpp
+++ b/src/language/node_processor/INodeProcessor.hpp
@@ -7,11 +7,11 @@
 #include <string>
 #include <typeinfo>
 
-#include <ASTNodeDataVariant.hpp>
+#include <DataVariant.hpp>
 
 struct INodeProcessor
 {
-  virtual ASTNodeDataVariant execute(ExecutionPolicy& exec_policy) = 0;
+  virtual DataVariant execute(ExecutionPolicy& exec_policy) = 0;
 
   std::string
   typeIdName() const
diff --git a/src/language/node_processor/IfProcessor.hpp b/src/language/node_processor/IfProcessor.hpp
index c7c735162ccfc3b3b85ce9e704de87ef22860116..2e655efce89cfa52c398d6785d174ab14987f803 100644
--- a/src/language/node_processor/IfProcessor.hpp
+++ b/src/language/node_processor/IfProcessor.hpp
@@ -9,7 +9,7 @@ class IfProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     const bool is_true = static_cast<bool>(std::visit(   // LCOV_EXCL_LINE (false negative)
diff --git a/src/language/node_processor/IncDecExpressionProcessor.hpp b/src/language/node_processor/IncDecExpressionProcessor.hpp
index 91f8259490ff3636efb3f606c84a9cfdb103355a..bbf223ef50d3fa99c5cbf17885189e827b2e1d94 100644
--- a/src/language/node_processor/IncDecExpressionProcessor.hpp
+++ b/src/language/node_processor/IncDecExpressionProcessor.hpp
@@ -57,10 +57,10 @@ class IncDecExpressionProcessor final : public INodeProcessor
 {
  private:
   ASTNode& m_node;
-  ASTNodeDataVariant* p_value{nullptr};
+  DataVariant* p_value{nullptr};
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy&)
   {
     return IncDecOp<IncDecOpT>().eval(std::get<DataT>(*p_value));
diff --git a/src/language/node_processor/LocalNameProcessor.hpp b/src/language/node_processor/LocalNameProcessor.hpp
index 6076fc37910248f39e9107120cc67bb6d05c431b..30d78b2da2f75a05402a5f1330d9020ab84b5808 100644
--- a/src/language/node_processor/LocalNameProcessor.hpp
+++ b/src/language/node_processor/LocalNameProcessor.hpp
@@ -13,7 +13,7 @@ class LocalNameProcessor final : public INodeProcessor
   uint64_t m_value_id;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     return exec_policy.context()[m_value_id];
diff --git a/src/language/node_processor/NameProcessor.hpp b/src/language/node_processor/NameProcessor.hpp
index c9515d7e97c13afdc77cd7bcb3b873a8e0cc014c..d8381c0f7d88da00473f590be1ee2a21783c5c28 100644
--- a/src/language/node_processor/NameProcessor.hpp
+++ b/src/language/node_processor/NameProcessor.hpp
@@ -10,10 +10,10 @@ class NameProcessor final : public INodeProcessor
 {
  private:
   ASTNode& m_node;
-  ASTNodeDataVariant* p_value{nullptr};
+  DataVariant* p_value{nullptr};
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy&)
   {
     return *p_value;
diff --git a/src/language/node_processor/OStreamProcessor.hpp b/src/language/node_processor/OStreamProcessor.hpp
index 3ce3ca063260782cd3f30bc8334728bf433ff040..db8404ab9297154e85397828825353b5a957964a 100644
--- a/src/language/node_processor/OStreamProcessor.hpp
+++ b/src/language/node_processor/OStreamProcessor.hpp
@@ -10,7 +10,7 @@ class OStreamProcessor final : public INodeProcessor
   std::ostream& m_os;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     for (size_t i = 0; i < m_node.children.size(); ++i) {
diff --git a/src/language/node_processor/UnaryExpressionProcessor.hpp b/src/language/node_processor/UnaryExpressionProcessor.hpp
index 7e5c539160003aa11b8f979181630e5c1719074b..56d6f8c27cb9029c8304c94294764669ee323b91 100644
--- a/src/language/node_processor/UnaryExpressionProcessor.hpp
+++ b/src/language/node_processor/UnaryExpressionProcessor.hpp
@@ -37,13 +37,13 @@ class UnaryExpressionProcessor final : public INodeProcessor
   ASTNode& m_node;
 
   PUGS_INLINE ValueT
-  _eval(const ASTNodeDataVariant& a)
+  _eval(const DataVariant& a)
   {
     return UnaryOp<UnaryOpT>().eval(static_cast<ValueT>(std::get<DataT>(a)));
   }
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     return this->_eval(m_node.children[0]->execute(exec_policy));
diff --git a/src/language/node_processor/ValueProcessor.hpp b/src/language/node_processor/ValueProcessor.hpp
index 134726f7b847f5f02825308427866c5fc1ba672b..59edc5bb3298377865e6794d95e90f858a8a478b 100644
--- a/src/language/node_processor/ValueProcessor.hpp
+++ b/src/language/node_processor/ValueProcessor.hpp
@@ -9,11 +9,11 @@
 class ValueProcessor final : public INodeProcessor
 {
  private:
-  ASTNodeDataVariant m_value;
+  DataVariant m_value;
 
  public:
   PUGS_INLINE
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy&)
   {
     return m_value;
diff --git a/src/language/node_processor/WhileProcessor.hpp b/src/language/node_processor/WhileProcessor.hpp
index 3f66194bf5ae89fca0150e43241262b19f4c4312..ae1f738fdedeb5f046548b583e02d2f375de90b9 100644
--- a/src/language/node_processor/WhileProcessor.hpp
+++ b/src/language/node_processor/WhileProcessor.hpp
@@ -9,7 +9,7 @@ class WhileProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
-  ASTNodeDataVariant
+  DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
     ExecutionPolicy exec_until_jump;
diff --git a/tests/test_CFunctionEmbedder.cpp b/tests/test_CFunctionEmbedder.cpp
index df76af84cb2dbd2b1597af16f26a0789962a831e..8b8213f69ec8410fcf3865bf6288bff9472f0626 100644
--- a/tests/test_CFunctionEmbedder.cpp
+++ b/tests/test_CFunctionEmbedder.cpp
@@ -11,10 +11,10 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     CFunctionEmbedder<double, double> embedded_sin{
       std::function<double(double)>{[](double x) -> double { return std::sin(x); }}};
 
-    double arg                     = 2;
-    ASTNodeDataVariant arg_variant = arg;
+    double arg              = 2;
+    DataVariant arg_variant = arg;
 
-    ASTNodeDataVariant result = embedded_sin.apply({arg_variant});
+    DataVariant result = embedded_sin.apply({arg_variant});
 
     REQUIRE(std::get<double>(result) == std::sin(arg));
     REQUIRE(embedded_sin.numberOfParameters() == 1);
@@ -32,11 +32,11 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     double d_arg   = 2.3;
     uint64_t i_arg = 3;
 
-    std::vector<ASTNodeDataVariant> args;
+    std::vector<DataVariant> args;
     args.push_back(d_arg);
     args.push_back(i_arg);
 
-    ASTNodeDataVariant result = embedded_c.apply(args);
+    DataVariant result = embedded_c.apply(args);
 
     REQUIRE(std::get<bool>(result) == c(d_arg, i_arg));
     REQUIRE(embedded_c.numberOfParameters() == 2);
@@ -55,11 +55,11 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     double d_arg   = 2.3;
     uint64_t i_arg = 3;
 
-    std::vector<ASTNodeDataVariant> args;
+    std::vector<DataVariant> args;
     args.push_back(d_arg);
     args.push_back(i_arg);
 
-    ASTNodeDataVariant result = i_embedded_c->apply(args);
+    DataVariant result = i_embedded_c->apply(args);
 
     REQUIRE(std::get<bool>(result) == c(d_arg, i_arg));
     REQUIRE(i_embedded_c->numberOfParameters() == 2);
@@ -77,7 +77,7 @@ TEST_CASE("CFunctionEmbedder", "[language]")
 
     std::string arg = std::string{"2.3"};
 
-    std::vector<ASTNodeDataVariant> args;
+    std::vector<DataVariant> args;
     args.push_back(arg);
 
     REQUIRE_THROWS(embedded_positive.apply(args));
diff --git a/tests/test_CMathModule.cpp b/tests/test_CMathModule.cpp
index 9ef32bf86a3cb8f5d0b6d62bbd951ad46eea10e0..6ce55f54bf73b2da9088fe00e3a556b54fbbbfb2 100644
--- a/tests/test_CMathModule.cpp
+++ b/tests/test_CMathModule.cpp
@@ -18,7 +18,7 @@ TEST_CASE("CMathModule", "[language]")
   {
     double arg = 0.7;
 
-    ASTNodeDataVariant arg_variant = arg;
+    DataVariant arg_variant = arg;
 
     SECTION("sqrt")
     {
@@ -26,7 +26,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::sqrt(arg);
 
@@ -40,7 +40,7 @@ TEST_CASE("CMathModule", "[language]")
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
       {
-        ASTNodeDataVariant result_variant = function_embedder.apply({arg_variant});
+        DataVariant result_variant = function_embedder.apply({arg_variant});
 
         auto result = std::abs(arg);
 
@@ -50,9 +50,9 @@ TEST_CASE("CMathModule", "[language]")
       {
         arg = -3;
 
-        ASTNodeDataVariant arg_variant = arg;
+        DataVariant arg_variant = arg;
 
-        ASTNodeDataVariant result_variant = function_embedder.apply({arg_variant});
+        DataVariant result_variant = function_embedder.apply({arg_variant});
 
         auto result = std::abs(arg);
 
@@ -66,7 +66,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::sin(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -78,7 +78,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::cos(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -90,7 +90,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::tan(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -102,7 +102,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::asin(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -114,7 +114,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::acos(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -126,7 +126,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::atan(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -141,7 +141,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::sinh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -153,7 +153,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::cosh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -165,7 +165,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::tanh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -177,7 +177,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::asinh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -192,7 +192,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::acosh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -204,7 +204,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::atanh(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -216,7 +216,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::exp(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -228,7 +228,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::log(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -240,7 +240,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::nearbyint(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -252,7 +252,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::ceil(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -264,7 +264,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::floor(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -276,7 +276,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::trunc(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -288,7 +288,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::round(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -300,7 +300,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::rint(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -311,7 +311,7 @@ TEST_CASE("CMathModule", "[language]")
   {
     double arg = 1.3;
 
-    ASTNodeDataVariant arg_variant = arg;
+    DataVariant arg_variant = arg;
 
     SECTION("lround")
     {
@@ -319,7 +319,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       auto result = std::lround(arg);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -331,7 +331,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg_variant});
+      DataVariant result_variant            = function_embedder.apply({arg_variant});
 
       //      REQUIRE(std::get<int64_t>(result_variant) == std::lrint(arg));
       auto result = std::lrint(arg);
@@ -344,8 +344,8 @@ TEST_CASE("CMathModule", "[language]")
     double arg0 = 3;
     double arg1 = 2;
 
-    ASTNodeDataVariant arg0_variant = arg0;
-    ASTNodeDataVariant arg1_variant = arg1;
+    DataVariant arg0_variant = arg0;
+    DataVariant arg1_variant = arg1;
 
     SECTION("atan2")
     {
@@ -353,7 +353,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg0_variant, arg1_variant});
+      DataVariant result_variant            = function_embedder.apply({arg0_variant, arg1_variant});
 
       auto result = std::atan2(arg0, arg1);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);
@@ -365,7 +365,7 @@ TEST_CASE("CMathModule", "[language]")
       REQUIRE(i_function != name_cfunction.end());
 
       ICFunctionEmbedder& function_embedder = *i_function->second;
-      ASTNodeDataVariant result_variant     = function_embedder.apply({arg0_variant, arg1_variant});
+      DataVariant result_variant            = function_embedder.apply({arg0_variant, arg1_variant});
 
       auto result = std::pow(arg0, arg1);
       REQUIRE(std::get<decltype(result)>(result_variant) == result);