diff --git a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
index b23169088ed8779f0a51bc3e8144d4277e19de9e..0f308f081e15bf4d09851b368c986743403a5e16 100644
--- a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
@@ -51,7 +51,7 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
           break;
         }
         case ASTNodeDataType::list_t: {
-          n.m_node_processor = std::make_unique<AffectationFromListProcessor<OperatorT, ValueT>>(n);
+          n.m_node_processor = std::make_unique<AffectationToTinyVectorFromListProcessor<OperatorT, ValueT>>(n);
           break;
         }
         case ASTNodeDataType::bool_t: {
@@ -222,15 +222,62 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
 
     auto set_affectation_processor_for_tuple_data = [&](const ASTNodeDataType& content_data_type,
                                                         const ASTNodeDataType& data_type) {
-      if (content_data_type != ASTNodeDataType::type_id_t) {
-        throw NotImplementedError(dataTypeName(content_data_type) + " argument to tuple ");
-      }
-
       using OperatorT = std::decay_t<decltype(operator_v)>;
       if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
         switch (data_type) {
         case ASTNodeDataType::list_t: {
-          n.m_node_processor = std::make_unique<AffectationFromListProcessor<OperatorT, EmbeddedData>>(n);
+          switch (content_data_type) {
+          case ASTNodeDataType::type_id_t: {
+            n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, EmbeddedData>>(n);
+            break;
+          }
+          case ASTNodeDataType::bool_t: {
+            n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, bool>>(n);
+            break;
+          }
+          case ASTNodeDataType::unsigned_int_t: {
+            n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, uint64_t>>(n);
+            break;
+          }
+          case ASTNodeDataType::int_t: {
+            n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, int64_t>>(n);
+            break;
+          }
+          case ASTNodeDataType::double_t: {
+            n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, double>>(n);
+            break;
+          }
+          case ASTNodeDataType::string_t: {
+            n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, std::string>>(n);
+            break;
+          }
+          case ASTNodeDataType::vector_t: {
+            switch (content_data_type.dimension()) {
+            case 1: {
+              n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, TinyVector<1>>>(n);
+              break;
+            }
+            case 2: {
+              n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, TinyVector<2>>>(n);
+              break;
+            }
+            case 3: {
+              n.m_node_processor = std::make_unique<AffectationToTupleFromListProcessor<OperatorT, TinyVector<3>>>(n);
+              break;
+            }
+              // LCOV_EXCL_START
+            default: {
+              throw parse_error("unexpected error: invalid vector dimension for string affectation",
+                                std::vector{n.children[1]->begin()});
+            }
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+          default: {
+            throw NotImplementedError(dataTypeName(content_data_type) + " argument to tuple ");
+          }
+          }
           break;
         }
         // LCOV_EXCL_START
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index 9e1508a80eacf3609270714f44aa2445b38b6a23..a2b41c3e0037f54bc33cf7254c6b22fc6732c3f2 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -341,7 +341,7 @@ class AffectationProcessor final : public INodeProcessor
 };
 
 template <typename OperatorT, typename ValueT>
-class AffectationFromListProcessor final : public INodeProcessor
+class AffectationToTinyVectorFromListProcessor final : public INodeProcessor
 {
  private:
   ASTNode& m_node;
@@ -377,7 +377,7 @@ class AffectationFromListProcessor final : public INodeProcessor
     return {};
   }
 
-  AffectationFromListProcessor(ASTNode& node) : m_node{node}
+  AffectationToTinyVectorFromListProcessor(ASTNode& node) : m_node{node}
   {
     const std::string& symbol = m_node.children[0]->string();
     auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
@@ -387,8 +387,8 @@ class AffectationFromListProcessor final : public INodeProcessor
   }
 };
 
-template <typename OperatorT>
-class AffectationFromListProcessor<OperatorT, EmbeddedData> final : public INodeProcessor
+template <typename OperatorT, typename ValueT>
+class AffectationToTupleFromListProcessor final : public INodeProcessor
 {
  private:
   ASTNode& m_node;
@@ -403,13 +403,24 @@ class AffectationFromListProcessor<OperatorT, EmbeddedData> final : public INode
 
     static_assert(std::is_same_v<OperatorT, language::eq_op>, "forbidden affection operator for list to vectors");
 
-    std::vector<EmbeddedData> tuple_value(children_values.size());
+    std::vector<ValueT> tuple_value(children_values.size());
     for (size_t i = 0; i < children_values.size(); ++i) {
       std::visit(
         [&](auto&& child_value) {
           using T = std::decay_t<decltype(child_value)>;
-          if constexpr (std::is_same_v<T, EmbeddedData>) {
+          if constexpr (std::is_same_v<T, ValueT>) {
             tuple_value[i] = child_value;
+          } else if constexpr (std::is_arithmetic_v<ValueT> and std::is_convertible_v<T, ValueT>) {
+            tuple_value[i] = static_cast<ValueT>(child_value);
+          } else if constexpr (std::is_same_v<std::string, ValueT>) {
+            if constexpr (std::is_arithmetic_v<T>) {
+              tuple_value[i] = std::to_string(child_value);
+            } else {
+              std::ostringstream os;
+              os << child_value << std::ends;
+              tuple_value[i] = os.str();
+            }
+
           } else {
             // LCOV_EXCL_START
             throw parse_error("unexpected error: unexpected right hand side type in affectation", m_node.begin());
@@ -423,7 +434,7 @@ class AffectationFromListProcessor<OperatorT, EmbeddedData> final : public INode
     return {};
   }
 
-  AffectationFromListProcessor(ASTNode& node) : m_node{node}
+  AffectationToTupleFromListProcessor(ASTNode& node) : m_node{node}
   {
     const std::string& symbol = m_node.children[0]->string();
     auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
diff --git a/tests/test_ASTNodeAffectationExpressionBuilder.cpp b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
index db62cbfbcf60b80d4269c6cd98f3faf4502a8fe1..f439786a088c0eb293019bf8e048fc56e8eda1e8 100644
--- a/tests/test_ASTNodeAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
@@ -377,7 +377,7 @@ let y : R^2, y = (0,1);
 
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ `-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
      +-(language::name:y:NameProcessor)
      `-(language::expression_list:ASTNodeExpressionListProcessor)
          +-(language::integer:0:ValueProcessor)
@@ -444,7 +444,7 @@ let y : R^3, y = (1,2,3);
 
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ `-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
      +-(language::name:y:NameProcessor)
      `-(language::expression_list:ASTNodeExpressionListProcessor)
          +-(language::integer:1:ValueProcessor)
diff --git a/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp b/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
index 18dcb85c16a95e13513aa78dc33ca7b9482ef89f..78a3f5f3b16bfdcb804421cc41e59a1c37abde4f 100644
--- a/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
+++ b/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
@@ -168,7 +168,7 @@ let x : R^2, x = (3.2,6);
 
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::real:3.2:ValueProcessor)
@@ -190,7 +190,7 @@ let x : R^3, x = (3.2,6,1.2);
 
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::real:3.2:ValueProcessor)
@@ -408,12 +408,12 @@ x+y;
 
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:y:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::real:0.3:ValueProcessor)
@@ -436,13 +436,13 @@ x+y;
 
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       +-(language::integer:2:ValueProcessor)
  |       `-(language::integer:3:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:y:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:4:ValueProcessor)
@@ -662,12 +662,12 @@ x-y;
 
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:y:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::real:0.3:ValueProcessor)
@@ -690,13 +690,13 @@ x-y;
 
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       +-(language::integer:2:ValueProcessor)
  |       `-(language::integer:3:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:y:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:4:ValueProcessor)
@@ -1195,12 +1195,12 @@ x==y;
 
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:y:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::real:0.3:ValueProcessor)
@@ -1223,13 +1223,13 @@ x==y;
 
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       +-(language::integer:2:ValueProcessor)
  |       `-(language::integer:3:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:y:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:4:ValueProcessor)
@@ -1348,12 +1348,12 @@ x!=y;
 
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:y:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::real:0.3:ValueProcessor)
@@ -1376,13 +1376,13 @@ x!=y;
 
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       +-(language::integer:2:ValueProcessor)
  |       `-(language::integer:3:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:y:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:4:ValueProcessor)
diff --git a/tests/test_ASTNodeExpressionBuilder.cpp b/tests/test_ASTNodeExpressionBuilder.cpp
index 8314e5a74d036c4ad2ff8a22a69ea3f68c6ceced..801d27d01f0dd89f206d5e9902c9e9414687559f 100644
--- a/tests/test_ASTNodeExpressionBuilder.cpp
+++ b/tests/test_ASTNodeExpressionBuilder.cpp
@@ -461,7 +461,7 @@ x[2];
 
       std::string result = R"(
 (root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:x:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
diff --git a/tests/test_ASTNodeListAffectationExpressionBuilder.cpp b/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
index 18a8687735a2bb7ff88b152543c96931db339a87..333b98bd998124e676c885025ef1d646ba517829 100644
--- a/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
@@ -172,12 +172,12 @@ let (x1,x2,x3,x) : R^1*R^2*R^3*R,
  +-(language::eq_op:AffectationFromZeroProcessor<TinyVector<1ul, double> >)
  |   +-(language::name:a:NameProcessor)
  |   `-(language::integer:0:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
  |   +-(language::name:b:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)
  |       `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
  |   +-(language::name:c:NameProcessor)
  |   `-(language::expression_list:ASTNodeExpressionListProcessor)
  |       +-(language::integer:1:ValueProcessor)