diff --git a/src/language/PEGGrammar.hpp b/src/language/PEGGrammar.hpp
index 2771a48e6a481a42400a6dd55ad7c67af44e8af2..78aaafe96e4795542a639144827851bbc3421029 100644
--- a/src/language/PEGGrammar.hpp
+++ b/src/language/PEGGrammar.hpp
@@ -161,8 +161,8 @@ struct vector_expression : if_must< open_bracket, list_must<expression, COMMA >,
 struct row_expression : if_must< open_bracket, list_must<expression, COMMA >, close_bracket >{};
 struct matrix_expression : seq< open_bracket, list_must<row_expression, COMMA >, close_bracket >{};
 
-struct tuple_expression;
-struct function_argument_list : if_must< open_parent, opt< list_must< sor< tuple_expression, expression >, COMMA > >, close_parent >{};
+struct inner_expression_list;
+struct function_argument_list : if_must< open_parent, opt< list_must< sor< inner_expression_list, expression >, COMMA > >, close_parent >{};
 struct function_evaluation : seq< NAME, function_argument_list > {};
 
 struct primary_expression : sor< BOOL, REAL, INTEGER, LITERAL, function_evaluation, NAME, parented_expression, matrix_expression, vector_expression >{};
@@ -233,12 +233,12 @@ struct logical_or : list_must< logical_and, or_op >{};
 
 struct expression : logical_or {};
 
-struct tuple_expression : seq< open_parent, expression, plus< if_must< COMMA, expression > >, close_parent >{};
+struct inner_expression_list : seq< open_parent, expression, plus< if_must< COMMA, expression > >, close_parent >{};
 
-struct expression_list : seq< open_parent, sor< seq< tuple_expression,
-						     star< if_must< COMMA, sor< tuple_expression, expression > > > >,
+struct expression_list : seq< open_parent, sor< seq< inner_expression_list,
+						     star< if_must< COMMA, sor< inner_expression_list, expression > > > >,
 						seq< expression,
-						     plus< if_must< COMMA, sor< tuple_expression, expression > >  > > >, close_parent >{};
+						     plus< if_must< COMMA, sor< inner_expression_list, expression > >  > > >, close_parent >{};
 
 struct affect_op : sor< eq_op, multiplyeq_op, divideeq_op, pluseq_op, minuseq_op > {};
 
diff --git a/src/language/ast/ASTBuilder.cpp b/src/language/ast/ASTBuilder.cpp
index 47642d04e2bc9a745a7962954844cd54f74d2ba0..4e380783e3af91072e130f9fa71a19164fcae08f 100644
--- a/src/language/ast/ASTBuilder.cpp
+++ b/src/language/ast/ASTBuilder.cpp
@@ -229,7 +229,7 @@ using selector = TAO_PEGTL_NAMESPACE::parse_tree::selector<
                                                      language::Z_set,
                                                      language::R_set,
                                                      language::type_name_id,
-                                                     language::tuple_expression,
+                                                     language::inner_expression_list,
                                                      language::vector_expression,
                                                      language::vector_type,
                                                      language::matrix_expression,
diff --git a/src/language/ast/ASTNodeDataTypeBuilder.cpp b/src/language/ast/ASTNodeDataTypeBuilder.cpp
index 2473205ae73d8caf552ac561c14907159d192622..6793bdcd1078fa738e1edd3f7a6146c4101e766c 100644
--- a/src/language/ast/ASTNodeDataTypeBuilder.cpp
+++ b/src/language/ast/ASTNodeDataTypeBuilder.cpp
@@ -298,7 +298,7 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
                n.is_type<language::minuseq_op>()) {
       n.m_data_type = ASTNodeDataType::build<ASTNodeDataType::void_t>();
 
-    } else if (n.is_type<language::tuple_expression>()) {
+    } else if (n.is_type<language::inner_expression_list>()) {
       std::vector<std::shared_ptr<const ASTNodeDataType>> sub_data_type_list;
       sub_data_type_list.reserve(n.children.size());
 
diff --git a/src/language/ast/ASTNodeExpressionBuilder.cpp b/src/language/ast/ASTNodeExpressionBuilder.cpp
index 4e61d118ead28e0a20345cc264a8bf3edc566d47..70722aea1a1ac73851df7157820a029e87266a66 100644
--- a/src/language/ast/ASTNodeExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeExpressionBuilder.cpp
@@ -16,11 +16,11 @@
 #include <language/node_processor/FakeProcessor.hpp>
 #include <language/node_processor/ForProcessor.hpp>
 #include <language/node_processor/IfProcessor.hpp>
+#include <language/node_processor/InnerListToVectorProcessor.hpp>
 #include <language/node_processor/LocalNameProcessor.hpp>
 #include <language/node_processor/NameProcessor.hpp>
 #include <language/node_processor/TinyMatrixExpressionProcessor.hpp>
 #include <language/node_processor/TinyVectorExpressionProcessor.hpp>
-#include <language/node_processor/TupleToVectorProcessor.hpp>
 #include <language/node_processor/ValueProcessor.hpp>
 #include <language/node_processor/WhileProcessor.hpp>
 #include <language/utils/ParseError.hpp>
@@ -52,8 +52,9 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
       ASTNodeAffectationExpressionBuilder{n};
     }
 
-  } else if (n.is_type<language::tuple_expression>()) {
-    n.m_node_processor = std::make_unique<TupleToVectorProcessor<ASTNodeExpressionListProcessor>>(n);
+  } else if (n.is_type<language::inner_expression_list>()) {
+    n.m_node_processor = std::make_unique<InnerListToVectorProcessor>(n);
+
   } else if (n.is_type<language::function_definition>()) {
     this->_checkIsPureFunction(n);
 
diff --git a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
index 6697967d2ab54950f7781ddfe41fa1c2197a28c8..8d77e1044e99750c3b9efba0157c4886264fa709 100644
--- a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
@@ -37,8 +37,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
     }
       // LCOV_EXCL_START
     default: {
-      throw ParseError("unexpected error: invalid operand type for affectation",
-                       std::vector{node_sub_data_type.m_parent_node.begin()});
+      throw UnexpectedError("invalid operand type for affectation");
     }
       // LCOV_EXCL_STOP
     }
@@ -63,17 +62,16 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
           list_affectation_processor->template add<ValueT, ZeroType>(value_node);
         } else {
           // LCOV_EXCL_START
-          throw ParseError("unexpected error: invalid operand value",
-                           std::vector{node_sub_data_type.m_parent_node.begin()});
+          throw UnexpectedError("unexpected error: invalid operand value");
           // LCOV_EXCL_STOP
         }
       } else {
         // LCOV_EXCL_START
-        throw ParseError("unexpected error: invalid dimension", std::vector{node_sub_data_type.m_parent_node.begin()});
+        throw UnexpectedError("invalid dimension");
         // LCOV_EXCL_STOP
       }
     } else {
-      throw ParseError("unexpected error: invalid value type", std::vector{node_sub_data_type.m_parent_node.begin()});
+      static_assert(std::is_same_v<ValueT, TinyVector<1>>, "unexpected value type");
     }
   };
 
@@ -98,17 +96,16 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
           list_affectation_processor->template add<ValueT, ZeroType>(value_node);
         } else {
           // LCOV_EXCL_START
-          throw ParseError("unexpected error: invalid operand value",
-                           std::vector{node_sub_data_type.m_parent_node.begin()});
+          throw UnexpectedError("invalid operand value");
           // LCOV_EXCL_STOP
         }
       } else {
         // LCOV_EXCL_START
-        throw ParseError("unexpected error: invalid dimension", std::vector{node_sub_data_type.m_parent_node.begin()});
+        throw UnexpectedError("invalid dimension");
         // LCOV_EXCL_STOP
       }
     } else {
-      throw ParseError("unexpected error: invalid value type", std::vector{node_sub_data_type.m_parent_node.begin()});
+      static_assert(std::is_same_v<ValueT, TinyMatrix<1>>, "unexpected value type");
     }
   };
 
@@ -201,7 +198,6 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
               break;
             }
             }
-            break;
           } else if (rhs_tuple_content == ASTNodeDataType::matrix_t) {
             Assert(rhs_tuple_content.numberOfRows() == rhs_tuple_content.numberOfColumns());
             switch (rhs_tuple_content.numberOfRows()) {
@@ -221,7 +217,129 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
               break;
             }
             }
+          } else {
+            // LCOV_EXCL_START
+            throw UnexpectedError("incompatible tuple types in affectation");
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::vector_t: {
+          switch (tuple_type.contentType().dimension()) {
+          case 1: {
+            if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<bool>>(value_node);
+            } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) {
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<uint64_t>>(value_node);
+            } else if (rhs_tuple_content == ASTNodeDataType::int_t) {
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<int64_t>>(value_node);
+            } else if (rhs_tuple_content == ASTNodeDataType::double_t) {
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<double>>(value_node);
+            } else if (rhs_tuple_content == ASTNodeDataType::vector_t) {
+              Assert(rhs_tuple_content.dimension() == 1);
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<TinyVector<1>>>(
+                value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
             break;
+          }
+          case 2: {
+            if (rhs_tuple_content == ASTNodeDataType::vector_t) {
+              Assert(rhs_tuple_content.dimension() == 2);
+              list_affectation_processor->template add<std::vector<TinyVector<2>>, std::vector<TinyVector<2>>>(
+                value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+          case 3: {
+            if (rhs_tuple_content == ASTNodeDataType::vector_t) {
+              Assert(rhs_tuple_content.dimension() == 3);
+              list_affectation_processor->template add<std::vector<TinyVector<3>>, std::vector<TinyVector<3>>>(
+                value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+            // LCOV_EXCL_START
+          default: {
+            throw UnexpectedError("invalid dimension");
+          }
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::matrix_t: {
+          Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns());
+          switch (tuple_type.contentType().numberOfRows()) {
+          case 1: {
+            if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<bool>>(value_node);
+            } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) {
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<uint64_t>>(value_node);
+            } else if (rhs_tuple_content == ASTNodeDataType::int_t) {
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<int64_t>>(value_node);
+            } else if (rhs_tuple_content == ASTNodeDataType::double_t) {
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<double>>(value_node);
+            } else if (rhs_tuple_content == ASTNodeDataType::matrix_t) {
+              Assert(rhs_tuple_content.numberOfRows() == 1);
+              Assert(rhs_tuple_content.numberOfColumns() == 1);
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<TinyMatrix<1>>>(
+                value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+          case 2: {
+            if (rhs_tuple_content == ASTNodeDataType::matrix_t) {
+              Assert(rhs_tuple_content.numberOfRows() == 2);
+              Assert(rhs_tuple_content.numberOfColumns() == 2);
+              list_affectation_processor->template add<std::vector<TinyMatrix<2>>, std::vector<TinyMatrix<2>>>(
+                value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+          case 3: {
+            if (rhs_tuple_content == ASTNodeDataType::matrix_t) {
+              Assert(rhs_tuple_content.numberOfRows() == 3);
+              Assert(rhs_tuple_content.numberOfColumns() == 3);
+              list_affectation_processor->template add<std::vector<TinyMatrix<3>>, std::vector<TinyMatrix<3>>>(
+                value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+            // LCOV_EXCL_START
+          default: {
+            throw UnexpectedError("invalid dimension");
+          }
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::type_id_t: {
+          if (rhs_tuple_content == ASTNodeDataType::type_id_t) {
+            Assert(rhs_tuple_content.nameOfTypeId() == tuple_type.contentType().nameOfTypeId());
+            list_affectation_processor->template add<std::vector<EmbeddedData>, std::vector<EmbeddedData>>(value_node);
           } else {
             // LCOV_EXCL_START
             throw UnexpectedError("incompatible tuple types in affectation");
@@ -231,23 +349,319 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
         }
           // LCOV_EXCL_START
         default: {
-          throw ParseError("unexpected error:invalid operand type for tuple affectation",
-                           std::vector{node_sub_data_type.m_parent_node.begin()});
+          throw UnexpectedError("invalid operand type for tuple affectation");
         }
           // LCOV_EXCL_STOP
         }
       } else if (node_sub_data_type.m_data_type == ASTNodeDataType::list_t) {
-        list_affectation_processor->template add<std::vector<std::string>, AggregateDataVariant>(value_node);
-        //        throw NotImplementedError("here");
+        switch (tuple_type.contentType()) {
+        case ASTNodeDataType::bool_t: {
+          list_affectation_processor->template add<std::vector<bool>, AggregateDataVariant>(value_node);
+          break;
+        }
+        case ASTNodeDataType::unsigned_int_t: {
+          list_affectation_processor->template add<std::vector<uint64_t>, AggregateDataVariant>(value_node);
+          break;
+        }
+        case ASTNodeDataType::int_t: {
+          list_affectation_processor->template add<std::vector<int64_t>, AggregateDataVariant>(value_node);
+          break;
+        }
+        case ASTNodeDataType::double_t: {
+          list_affectation_processor->template add<std::vector<double_t>, AggregateDataVariant>(value_node);
+          break;
+        }
+        case ASTNodeDataType::string_t: {
+          list_affectation_processor->template add<std::vector<std::string>, AggregateDataVariant>(value_node);
+          break;
+        }
+        case ASTNodeDataType::vector_t: {
+          switch (tuple_type.contentType().dimension()) {
+          case 1: {
+            list_affectation_processor->template add<std::vector<TinyVector<1>>, AggregateDataVariant>(value_node);
+            break;
+          }
+          case 2: {
+            list_affectation_processor->template add<std::vector<TinyVector<2>>, AggregateDataVariant>(value_node);
+            break;
+          }
+          case 3: {
+            list_affectation_processor->template add<std::vector<TinyVector<3>>, AggregateDataVariant>(value_node);
+            break;
+          }
+            // LCOV_EXCL_START
+          default: {
+            throw UnexpectedError("invalid vector dimension");
+          }
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::matrix_t: {
+          Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns());
+          switch (tuple_type.contentType().numberOfRows()) {
+          case 1: {
+            list_affectation_processor->template add<std::vector<TinyMatrix<1>>, AggregateDataVariant>(value_node);
+            break;
+          }
+          case 2: {
+            list_affectation_processor->template add<std::vector<TinyMatrix<2>>, AggregateDataVariant>(value_node);
+            break;
+          }
+          case 3: {
+            list_affectation_processor->template add<std::vector<TinyMatrix<3>>, AggregateDataVariant>(value_node);
+            break;
+          }
+            // LCOV_EXCL_START
+          default: {
+            throw UnexpectedError("invalid matrix dimension");
+          }
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::type_id_t: {
+          list_affectation_processor->template add<std::vector<EmbeddedData>, AggregateDataVariant>(value_node);
+          break;
+        }
+          // LCOV_EXCL_START
+        default: {
+          throw UnexpectedError("invalid operand type for tuple affectation");
+        }
+          // LCOV_EXCL_STOP
+        }
       } else {
-        // LCOV_EXCL_START
-        throw ParseError("unexpected error:invalid operand type for tuple affectation", std::vector{m_node.begin()});
-        // LCOV_EXCL_STOP
+        const ASTNodeDataType& rhs_type = node_sub_data_type.m_data_type;
+        switch (tuple_type.contentType()) {
+        case ASTNodeDataType::bool_t: {
+          if (rhs_type == ASTNodeDataType::bool_t) {
+            list_affectation_processor->template add<std::vector<bool>, bool>(value_node);
+          } else {
+            // LCOV_EXCL_START
+            throw UnexpectedError("incompatible tuple types in affectation");
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::unsigned_int_t: {
+          if (rhs_type == ASTNodeDataType::bool_t) {
+            list_affectation_processor->template add<std::vector<uint64_t>, bool>(value_node);
+          } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+            list_affectation_processor->template add<std::vector<uint64_t>, uint64_t>(value_node);
+          } else if (rhs_type == ASTNodeDataType::int_t) {
+            list_affectation_processor->template add<std::vector<uint64_t>, int64_t>(value_node);
+          } else {
+            // LCOV_EXCL_START
+            throw UnexpectedError("incompatible tuple types in affectation");
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::int_t: {
+          if (rhs_type == ASTNodeDataType::bool_t) {
+            list_affectation_processor->template add<std::vector<int64_t>, bool>(value_node);
+          } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+            list_affectation_processor->template add<std::vector<int64_t>, uint64_t>(value_node);
+          } else if (rhs_type == ASTNodeDataType::int_t) {
+            list_affectation_processor->template add<std::vector<int64_t>, int64_t>(value_node);
+          } else {
+            // LCOV_EXCL_START
+            throw UnexpectedError("incompatible tuple types in affectation");
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::double_t: {
+          if (rhs_type == ASTNodeDataType::bool_t) {
+            list_affectation_processor->template add<std::vector<double>, bool>(value_node);
+          } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+            list_affectation_processor->template add<std::vector<double>, uint64_t>(value_node);
+          } else if (rhs_type == ASTNodeDataType::int_t) {
+            list_affectation_processor->template add<std::vector<double>, int64_t>(value_node);
+          } else if (rhs_type == ASTNodeDataType::double_t) {
+            list_affectation_processor->template add<std::vector<double>, double>(value_node);
+          } else {
+            // LCOV_EXCL_START
+            throw UnexpectedError("incompatible tuple types in affectation");
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::string_t: {
+          if (rhs_type == ASTNodeDataType::bool_t) {
+            list_affectation_processor->template add<std::vector<std::string>, bool>(value_node);
+          } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+            list_affectation_processor->template add<std::vector<std::string>, uint64_t>(value_node);
+          } else if (rhs_type == ASTNodeDataType::int_t) {
+            list_affectation_processor->template add<std::vector<std::string>, int64_t>(value_node);
+          } else if (rhs_type == ASTNodeDataType::double_t) {
+            list_affectation_processor->template add<std::vector<std::string>, double>(value_node);
+          } else if (rhs_type == ASTNodeDataType::string_t) {
+            list_affectation_processor->template add<std::vector<std::string>, std::string>(value_node);
+          } else if (rhs_type == ASTNodeDataType::vector_t) {
+            switch (rhs_type.dimension()) {
+            case 1: {
+              list_affectation_processor->template add<std::vector<std::string>, TinyVector<1>>(value_node);
+              break;
+            }
+            case 2: {
+              list_affectation_processor->template add<std::vector<std::string>, TinyVector<2>>(value_node);
+              break;
+            }
+            case 3: {
+              list_affectation_processor->template add<std::vector<std::string>, TinyVector<3>>(value_node);
+              break;
+            }
+            }
+          } else if (rhs_type == ASTNodeDataType::matrix_t) {
+            Assert(rhs_type.numberOfRows() == rhs_type.numberOfColumns());
+            switch (rhs_type.numberOfRows()) {
+            case 1: {
+              list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<1>>(value_node);
+              break;
+            }
+            case 2: {
+              list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<2>>(value_node);
+              break;
+            }
+            case 3: {
+              list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<3>>(value_node);
+              break;
+            }
+            }
+          } else {
+            // LCOV_EXCL_START
+            throw UnexpectedError("incompatible rhs type in tuple affectation");
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::vector_t: {
+          switch (tuple_type.contentType().dimension()) {
+          case 1: {
+            if (rhs_type == ASTNodeDataType::bool_t) {
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, bool>(value_node);
+            } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, uint64_t>(value_node);
+            } else if (rhs_type == ASTNodeDataType::int_t) {
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, int64_t>(value_node);
+            } else if (rhs_type == ASTNodeDataType::double_t) {
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, double>(value_node);
+            } else if (rhs_type == ASTNodeDataType::vector_t) {
+              Assert(rhs_type.dimension() == 1);
+              list_affectation_processor->template add<std::vector<TinyVector<1>>, TinyVector<1>>(value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+          case 2: {
+            if (rhs_type == ASTNodeDataType::vector_t) {
+              Assert(rhs_type.dimension() == 2);
+              list_affectation_processor->template add<std::vector<TinyVector<2>>, TinyVector<2>>(value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+          case 3: {
+            if (rhs_type == ASTNodeDataType::vector_t) {
+              Assert(rhs_type.dimension() == 3);
+              list_affectation_processor->template add<std::vector<TinyVector<3>>, TinyVector<3>>(value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+            // LCOV_EXCL_START
+          default: {
+            throw UnexpectedError("invalid vector dimension for tuple affectation");
+          }
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::matrix_t: {
+          Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns());
+          switch (tuple_type.contentType().numberOfRows()) {
+          case 1: {
+            if (rhs_type == ASTNodeDataType::bool_t) {
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, bool>(value_node);
+            } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, uint64_t>(value_node);
+            } else if (rhs_type == ASTNodeDataType::int_t) {
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, int64_t>(value_node);
+            } else if (rhs_type == ASTNodeDataType::double_t) {
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, double>(value_node);
+            } else if (rhs_type == ASTNodeDataType::matrix_t) {
+              Assert(rhs_type.numberOfRows() == 1);
+              Assert(rhs_type.numberOfColumns() == 1);
+              list_affectation_processor->template add<std::vector<TinyMatrix<1>>, TinyMatrix<1>>(value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+          case 2: {
+            if (rhs_type == ASTNodeDataType::matrix_t) {
+              Assert(rhs_type.numberOfRows() == 2);
+              Assert(rhs_type.numberOfColumns() == 2);
+              list_affectation_processor->template add<std::vector<TinyMatrix<2>>, TinyMatrix<2>>(value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+          case 3: {
+            if (rhs_type == ASTNodeDataType::matrix_t) {
+              Assert(rhs_type.numberOfRows() == 3);
+              Assert(rhs_type.numberOfColumns() == 3);
+              list_affectation_processor->template add<std::vector<TinyMatrix<3>>, TinyMatrix<3>>(value_node);
+            } else {
+              // LCOV_EXCL_START
+              throw UnexpectedError("incompatible tuple types in affectation");
+              // LCOV_EXCL_STOP
+            }
+            break;
+          }
+            // LCOV_EXCL_START
+          default: {
+            throw UnexpectedError("invalid vector dimension for tuple affectation");
+          }
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+        case ASTNodeDataType::type_id_t: {
+          if (rhs_type == ASTNodeDataType::type_id_t) {
+            Assert(rhs_type.nameOfTypeId() == tuple_type.contentType().nameOfTypeId());
+            list_affectation_processor->template add<std::vector<EmbeddedData>, EmbeddedData>(value_node);
+          } else {
+            // LCOV_EXCL_START
+            throw UnexpectedError("incompatible tuple types in affectation");
+            // LCOV_EXCL_STOP
+          }
+          break;
+        }
+          // LCOV_EXCL_START
+        default: {
+          throw UnexpectedError("invalid operand type for tuple affectation");
+        }
+          // LCOV_EXCL_STOP
+        }
       }
     } else {
-      // LCOV_EXCL_START
-      throw ParseError("unexpected error:invalid operand type for tuple affectation", std::vector{m_node.begin()});
-      // LCOV_EXCL_STOP
+      static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type");
     }
   };
 
@@ -260,14 +674,12 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
       }
         // LCOV_EXCL_START
       default: {
-        throw ParseError("unexpected error:invalid operand type for embedded data affectation",
-                         std::vector{node_sub_data_type.m_parent_node.begin()});
+        throw UnexpectedError("invalid operand type for embedded data affectation");
       }
         // LCOV_EXCL_STOP
       }
     } else {
-      throw ParseError("unexpected error: undefined operator type for embedded data affectation",
-                       std::vector{m_node.begin()});
+      static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type");
     }
   };
 
@@ -310,8 +722,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
         }
           // LCOV_EXCL_START
         default: {
-          throw ParseError("unexpected error: invalid vector dimension",
-                           std::vector{node_sub_data_type.m_parent_node.begin()});
+          throw UnexpectedError("invalid vector dimension");
         }
           // LCOV_EXCL_STOP
         }
@@ -334,8 +745,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
         }
           // LCOV_EXCL_START
         default: {
-          throw ParseError("unexpected error: invalid vector dimension",
-                           std::vector{node_sub_data_type.m_parent_node.begin()});
+          throw UnexpectedError("invalid vector dimension");
         }
           // LCOV_EXCL_STOP
         }
@@ -344,13 +754,12 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
 
         // LCOV_EXCL_START
       default: {
-        throw ParseError("unexpected error:invalid operand type for string affectation",
-                         std::vector{node_sub_data_type.m_parent_node.begin()});
+        throw UnexpectedError("invalid operand type for string affectation");
       }
         // LCOV_EXCL_STOP
       }
     } else {
-      throw ParseError("unexpected error: undefined operator type for string affectation", std::vector{m_node.begin()});
+      static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type");
     }
   };
 
@@ -393,7 +802,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
       }
         // LCOV_EXCL_START
       default: {
-        throw ParseError("invalid dimension", std::vector{value_node.begin()});
+        throw UnexpectedError("invalid dimension");
       }
         // LCOV_EXCL_STOP
       }
@@ -416,7 +825,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
       }
         // LCOV_EXCL_START
       default: {
-        throw ParseError("invalid dimension", std::vector{value_node.begin()});
+        throw UnexpectedError("invalid dimension");
       }
         // LCOV_EXCL_STOP
       }
@@ -432,7 +841,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
     }
       // LCOV_EXCL_START
     default: {
-      throw ParseError("unexpected error: undefined value type for tuple affectation", std::vector{value_node.begin()});
+      throw UnexpectedError("unexpected error: undefined value type for tuple affectation");
     }
       // LCOV_EXCL_STOP
     }
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index 933afbff4f297df12c7aa4751c20b62f69e9af77..af8482a22a614e683336fd4118dc703007f9a170 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -101,7 +101,7 @@ class AffectationExecutor final : public IAffectationExecutor
           if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
             if constexpr (std::is_same_v<std::string, DataT>) {
               m_lhs = std::get<DataT>(rhs);
-            } else if constexpr (std::is_arithmetic_v<DataT>) {
+            } else if constexpr (std::is_arithmetic_v<DataT> and not std::is_same_v<DataT, bool>) {
               m_lhs = std::to_string(std::get<DataT>(rhs));
             } else {
               std::ostringstream os;
@@ -111,7 +111,7 @@ class AffectationExecutor final : public IAffectationExecutor
           } else {
             if constexpr (std::is_same_v<std::string, DataT>) {
               m_lhs += std::get<std::string>(rhs);
-            } else if constexpr (std::is_arithmetic_v<DataT>) {
+            } else if constexpr (std::is_arithmetic_v<DataT> and not std::is_same_v<DataT, bool>) {
               m_lhs += std::to_string(std::get<DataT>(rhs));
             } else {
               std::ostringstream os;
@@ -153,9 +153,9 @@ class AffectationExecutor final : public IAffectationExecutor
               using ValueContentT = typename ValueT::value_type;
               using DataContentT  = typename DataT::value_type;
 
-              if constexpr (std::is_same_v<ValueContentT, DataContentT>) {
-                m_lhs = std::move(std::get<DataT>(rhs));
-              } else if constexpr (std::is_convertible_v<DataContentT, ValueContentT>) {
+              static_assert(not std::is_same_v<ValueContentT, DataContentT>,
+                            "the case should have been treated previously");
+              if constexpr (std::is_convertible_v<DataContentT, ValueContentT>) {
                 m_lhs.resize(std::get<DataT>(rhs).size());
                 std::visit(
                   [&](auto&& v) {
@@ -185,7 +185,7 @@ class AffectationExecutor final : public IAffectationExecutor
                     if constexpr (is_std_vector_v<std::decay_t<decltype(v)>>) {
                       using Vi_T = typename std::decay_t<decltype(v)>::value_type;
                       for (size_t i = 0; i < v.size(); ++i) {
-                        if constexpr (std::is_arithmetic_v<Vi_T>) {
+                        if constexpr (std::is_arithmetic_v<Vi_T> and not std::is_same_v<DataT, bool>) {
                           m_lhs[i] = std::move(std::to_string(v[i]));
                         } else {
                           std::ostringstream os;
@@ -200,6 +200,61 @@ class AffectationExecutor final : public IAffectationExecutor
                     }
                   },
                   rhs);
+              } else if constexpr (is_tiny_vector_v<ValueContentT>) {
+                static_assert(not std::is_same_v<DataContentT, ValueContentT>, "should have been treated before");
+                static_assert(ValueContentT::Dimension == 1,
+                              "conversions are only allowed for dimension 1 TinyVector's");
+
+                m_lhs.resize(std::get<DataT>(rhs).size());
+
+                std::visit(
+                  [&](auto&& v) {
+                    if constexpr (is_std_vector_v<std::decay_t<decltype(v)>>) {
+                      using Vi_T = typename std::decay_t<decltype(v)>::value_type;
+                      for (size_t i = 0; i < v.size(); ++i) {
+                        if constexpr (std::is_arithmetic_v<Vi_T>) {
+                          m_lhs[i][0] = v[i];
+                        } else {
+                          // LCOV_EXCL_START
+                          throw UnexpectedError("unexpected rhs type in affectation");
+                          // LCOV_EXCL_STOP
+                        }
+                      }
+                    } else {
+                      // LCOV_EXCL_START
+                      throw UnexpectedError("unexpected rhs type in affectation");
+                      // LCOV_EXCL_STOP
+                    }
+                  },
+                  rhs);
+
+              } else if constexpr (is_tiny_matrix_v<ValueContentT>) {
+                static_assert(not std::is_same_v<DataContentT, ValueContentT>, "should have been treated before");
+                static_assert(ValueContentT::Dimension == 1, "conversions are only allowed for 1x1 TinyMatrix's");
+
+                m_lhs.resize(std::get<DataT>(rhs).size());
+
+                std::visit(
+                  [&](auto&& v) {
+                    if constexpr (is_std_vector_v<std::decay_t<decltype(v)>>) {
+                      using Vi_T = typename std::decay_t<decltype(v)>::value_type;
+                      for (size_t i = 0; i < v.size(); ++i) {
+                        if constexpr (std::is_arithmetic_v<Vi_T>) {
+                          m_lhs[i](0, 0) = v[i];
+                        } else {
+                          // LCOV_EXCL_START
+                          throw UnexpectedError("unexpected rhs type in affectation");
+                          // LCOV_EXCL_STOP
+                        }
+                      }
+                    } else {
+                      // LCOV_EXCL_START
+                      throw UnexpectedError("unexpected rhs type in affectation");
+                      // LCOV_EXCL_STOP
+                    }
+                  },
+                  rhs);
+
               } else {
                 // LCOV_EXCL_START
                 throw UnexpectedError("invalid value type");
@@ -220,7 +275,7 @@ class AffectationExecutor final : public IAffectationExecutor
                                          std::is_convertible_v<T, ValueContentT>) {
                       tuple_value[i] = static_cast<ValueContentT>(child_value);
                     } else if constexpr (std::is_same_v<std::string, ValueContentT>) {
-                      if constexpr (std::is_arithmetic_v<T>) {
+                      if constexpr (std::is_arithmetic_v<T> and not std::is_same_v<T, bool>) {
                         tuple_value[i] = std::to_string(child_value);
                       } else {
                         std::ostringstream os;
@@ -263,7 +318,62 @@ class AffectationExecutor final : public IAffectationExecutor
                   },
                   children_values[i]);
               }
-              //              throw NotImplementedError("list -> tuple");
+            } else if constexpr (is_std_vector_v<ValueT>) {
+              using ValueContentT = typename ValueT::value_type;
+              m_lhs.resize(1);
+              auto& tuple_value = m_lhs;
+              std::visit(
+                [&](auto&& child_value) {
+                  using T = std::decay_t<decltype(child_value)>;
+                  if constexpr (std::is_same_v<T, ValueContentT>) {
+                    tuple_value[0] = child_value;
+                  } else if constexpr (std::is_arithmetic_v<ValueContentT> and
+                                       std::is_convertible_v<T, ValueContentT>) {
+                    tuple_value[0] = static_cast<ValueContentT>(child_value);
+                  } else if constexpr (std::is_same_v<std::string, ValueContentT>) {
+                    if constexpr (std::is_arithmetic_v<T> and not std::is_same_v<DataT, bool>) {
+                      tuple_value[0] = std::to_string(child_value);
+                    } else {
+                      std::ostringstream os;
+                      os << std::boolalpha << child_value;
+                      tuple_value[0] = os.str();
+                    }
+                  } else if constexpr (is_tiny_vector_v<ValueContentT>) {
+                    if constexpr (std::is_arithmetic_v<T>) {
+                      if constexpr (std::is_same_v<ValueContentT, TinyVector<1>>) {
+                        tuple_value[0][0] = child_value;
+                      } else {
+                        // in this case a 0 is given
+                        Assert(child_value == 0);
+                        tuple_value[0] = ZeroType{};
+                      }
+                    } else {
+                      // LCOV_EXCL_START
+                      throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+                      // LCOV_EXCL_STOP
+                    }
+                  } else if constexpr (is_tiny_matrix_v<ValueContentT>) {
+                    if constexpr (std::is_arithmetic_v<T>) {
+                      if constexpr (std::is_same_v<ValueContentT, TinyMatrix<1>>) {
+                        tuple_value[0](0, 0) = child_value;
+                      } else {
+                        // in this case a 0 is given
+                        Assert(child_value == 0);
+                        tuple_value[0] = ZeroType{};
+                      }
+                    } else {
+                      // LCOV_EXCL_START
+                      throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+                      // LCOV_EXCL_STOP
+                    }
+                  } else {
+                    // LCOV_EXCL_START
+                    throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+                    // LCOV_EXCL_STOP
+                  }
+                },
+                rhs);
+
             } else {
               // LCOV_EXCL_START
               throw UnexpectedError("invalid value type");
@@ -364,7 +474,7 @@ class AffectationToTupleProcessor final : public AffectationToDataVariantProcess
         } else if constexpr (std::is_arithmetic_v<ValueT> and std::is_convertible_v<T, ValueT>) {
           *m_lhs = std::vector{std::move(static_cast<ValueT>(v))};
         } else if constexpr (std::is_same_v<std::string, ValueT>) {
-          if constexpr (std::is_arithmetic_v<T>) {
+          if constexpr (std::is_arithmetic_v<T> and not std::is_same_v<T, bool>) {
             *m_lhs = std::vector{std::move(std::to_string(v))};
           } else {
             std::ostringstream os;
@@ -419,7 +529,7 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
           } 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>) {
+            if constexpr (std::is_arithmetic_v<T> and not std::is_same_v<T, bool>) {
               tuple_value[i] = std::to_string(child_value);
             } else {
               std::ostringstream os;
diff --git a/src/language/node_processor/InnerListToVectorProcessor.hpp b/src/language/node_processor/InnerListToVectorProcessor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef74daaabe5c0e2f475b1693b7bb9627ed600f40
--- /dev/null
+++ b/src/language/node_processor/InnerListToVectorProcessor.hpp
@@ -0,0 +1,30 @@
+#ifndef INNER_LIST_TO_VECTOR_PROCESSOR_HPP
+#define INNER_LIST_TO_VECTOR_PROCESSOR_HPP
+
+#include <language/ast/ASTNode.hpp>
+#include <language/node_processor/ASTNodeExpressionListProcessor.hpp>
+#include <language/node_processor/INodeProcessor.hpp>
+
+class InnerListToVectorProcessor final : public INodeProcessor
+{
+ private:
+  std::unique_ptr<ASTNodeExpressionListProcessor> m_expression_list_processor;
+
+ public:
+  DataVariant
+  execute(ExecutionPolicy& exec_policy)
+  {
+    AggregateDataVariant v = std::get<AggregateDataVariant>(m_expression_list_processor->execute(exec_policy));
+
+    v.setIsFlattenable(false);
+    return v;
+  }
+
+  InnerListToVectorProcessor(ASTNode& node)
+    : m_expression_list_processor{std::make_unique<ASTNodeExpressionListProcessor>(node)}
+  {}
+
+  ~InnerListToVectorProcessor() = default;
+};
+
+#endif   // INNER_LIST_TO_VECTOR_PROCESSOR_HPP
diff --git a/src/language/node_processor/TupleToVectorProcessor.hpp b/src/language/node_processor/TupleToVectorProcessor.hpp
deleted file mode 100644
index 74ad59acb95e0e853a880fb171e93d77c55dcd74..0000000000000000000000000000000000000000
--- a/src/language/node_processor/TupleToVectorProcessor.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef TUPLE_TO_VECTOR_PROCESSOR_HPP
-#define TUPLE_TO_VECTOR_PROCESSOR_HPP
-
-#include <language/ast/ASTNode.hpp>
-#include <language/node_processor/INodeProcessor.hpp>
-
-template <typename TupleProcessorT>
-class TupleToVectorProcessor final : public INodeProcessor
-{
- private:
-  ASTNode& m_node;
-
-  std::unique_ptr<TupleProcessorT> m_tuple_processor;
-
- public:
-  DataVariant
-  execute(ExecutionPolicy& exec_policy)
-  {
-    AggregateDataVariant v = std::get<AggregateDataVariant>(m_tuple_processor->execute(exec_policy));
-
-    v.setIsFlattenable(false);
-    return v;
-  }
-
-  TupleToVectorProcessor(ASTNode& node) : m_node{node}, m_tuple_processor{std::make_unique<TupleProcessorT>(node)} {}
-
-  TupleToVectorProcessor(ASTNode& node, std::unique_ptr<TupleProcessorT>&& tuple_processor)
-    : m_node{node}, m_tuple_processor{std::move(tuple_processor)}
-  {}
-};
-
-#endif   // TUPLE_TO_TINY_VECTOR_PROCESSOR_HPP
diff --git a/tests/test_ASTBuilder.cpp b/tests/test_ASTBuilder.cpp
index 262a0cd30b60cee5da070fe6fa8d62d8981e7b1d..2a9bcf4e41c039ac87dd6d3535a47710fb1a86e7 100644
--- a/tests/test_ASTBuilder.cpp
+++ b/tests/test_ASTBuilder.cpp
@@ -636,10 +636,10 @@ let y:(R^2), y=((0));
  |   |       `-(language::integer:2)
  |   +-(language::name:x)
  |   `-(language::expression_list)
- |       +-(language::tuple_expression)
+ |       +-(language::inner_expression_list)
  |       |   +-(language::integer:0)
  |       |   `-(language::integer:0)
- |       `-(language::tuple_expression)
+ |       `-(language::inner_expression_list)
  |           +-(language::integer:2)
  |           `-(language::integer:3)
  `-(language::var_declaration)
diff --git a/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp b/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
index 7c96baebb0ad6b9771bda10b7065dd72208b5b09..05b64ce5127758d9772e297c5d8a2c62bb62119c 100644
--- a/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
+++ b/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
@@ -1229,7 +1229,7 @@ tuple_RtoB((1.2, 2, true, n));
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:BuiltinFunctionProcessor)
      +-(language::name:tuple_RtoB:FakeProcessor)
-     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+     `-(language::inner_expression_list:InnerListToVectorProcessor)
          +-(language::real:1.2:ValueProcessor)
          +-(language::integer:2:ValueProcessor)
          +-(language::true_kw:ValueProcessor)
@@ -1332,7 +1332,7 @@ tuple_stringtoB(("foo",2,"bar"));
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:BuiltinFunctionProcessor)
      +-(language::name:tuple_stringtoB:FakeProcessor)
-     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+     `-(language::inner_expression_list:InnerListToVectorProcessor)
          +-(language::literal:"foo":ValueProcessor)
          +-(language::integer:2:ValueProcessor)
          `-(language::literal:"bar":ValueProcessor)
@@ -1367,7 +1367,7 @@ tuple_builtinToB((a,b,a));
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:BuiltinFunctionProcessor)
      +-(language::name:tuple_builtinToB:FakeProcessor)
-     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+     `-(language::inner_expression_list:InnerListToVectorProcessor)
          +-(language::name:a:NameProcessor)
          +-(language::name:b:NameProcessor)
          `-(language::name:a:NameProcessor)
@@ -1535,7 +1535,7 @@ tuple_R2ToR((r,r));
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:BuiltinFunctionProcessor)
      +-(language::name:tuple_R2ToR:FakeProcessor)
-     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+     `-(language::inner_expression_list:InnerListToVectorProcessor)
          +-(language::name:r:NameProcessor)
          `-(language::name:r:NameProcessor)
 )";
@@ -1587,7 +1587,7 @@ tuple_R22ToR((r,r));
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:BuiltinFunctionProcessor)
      +-(language::name:tuple_R22ToR:FakeProcessor)
-     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+     `-(language::inner_expression_list:InnerListToVectorProcessor)
          +-(language::name:r:NameProcessor)
          `-(language::name:r:NameProcessor)
 )";
@@ -1689,7 +1689,7 @@ fidTupleToR((f,f));
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:BuiltinFunctionProcessor)
      +-(language::name:fidTupleToR:FakeProcessor)
-     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+     `-(language::inner_expression_list:InnerListToVectorProcessor)
          +-(language::name:f:NameProcessor)
          `-(language::name:f:NameProcessor)
 )";
diff --git a/tests/test_ASTNodeListAffectationExpressionBuilder.cpp b/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
index 44f3d6713e9256cbaf0e12814200aac4f8b333fa..02aa43085baca268485d48af950cfde2f3485846 100644
--- a/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
@@ -330,6 +330,1019 @@ let  (x1,x2,x3,x) : R^1x1*R^2x2*R^3x3*R, (x1,x2,x3,x) = (0, 0, 0, 0);
       CHECK_AST(data, result);
     }
 
+    SECTION("with tuples from lists")
+    {
+      std::string_view data = R"(
+let  (x,n,s) : (R)*(N)*(string), (x,n,s) = ((1.2,3.4), (1,2,3), (2.1,4,3.3,17.2));
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:x:NameProcessor)
+     |   +-(language::name:n:NameProcessor)
+     |   `-(language::name:s:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::real:1.2:ValueProcessor)
+         |   `-(language::real:3.4:ValueProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::integer:1:ValueProcessor)
+         |   +-(language::integer:2:ValueProcessor)
+         |   `-(language::integer:3:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::real:2.1:ValueProcessor)
+             +-(language::integer:4:ValueProcessor)
+             +-(language::real:3.3:ValueProcessor)
+             `-(language::real:17.2:ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("with tuples from tuples")
+    {
+      SECTION("tuple of B")
+      {
+        std::string_view data = R"(
+let b:(B), b = (true, false);
+let  (b1,b2,b3) : (B)*(B)*(B), (b1,b2,b3) = (b, false, (true, true, false));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::true_kw:ValueProcessor)
+ |       `-(language::false_kw:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:b1:NameProcessor)
+     |   +-(language::name:b2:NameProcessor)
+     |   `-(language::name:b3:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:b:NameProcessor)
+         +-(language::false_kw:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::true_kw:ValueProcessor)
+             +-(language::true_kw:ValueProcessor)
+             `-(language::false_kw:ValueProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of N")
+      {
+        std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (n1,n2,n3,n4,n5,n6,n7,n8) : (N)*(N)*(N)*(N)*(N)*(N)*(N)*(N),
+    (n1,n2,n3,n4,n5,n6,n7,n8) = (b, n, z, false, 2, i1, (2, 3, 2), (i1, i2));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::true_kw:ValueProcessor)
+ |       `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ |   +-(language::name:z:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:1:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i1:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i2:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:n1:NameProcessor)
+     |   +-(language::name:n2:NameProcessor)
+     |   +-(language::name:n3:NameProcessor)
+     |   +-(language::name:n4:NameProcessor)
+     |   +-(language::name:n5:NameProcessor)
+     |   +-(language::name:n6:NameProcessor)
+     |   +-(language::name:n7:NameProcessor)
+     |   `-(language::name:n8:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:b:NameProcessor)
+         +-(language::name:n:NameProcessor)
+         +-(language::name:z:NameProcessor)
+         +-(language::false_kw:ValueProcessor)
+         +-(language::integer:2:ValueProcessor)
+         +-(language::name:i1:NameProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::integer:2:ValueProcessor)
+         |   +-(language::integer:3:ValueProcessor)
+         |   `-(language::integer:2:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::name:i1:NameProcessor)
+             `-(language::name:i2:NameProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of Z")
+      {
+        std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (z1,z2,z3,z4,z5,z6,z7,z8) : (Z)*(Z)*(Z)*(Z)*(Z)*(Z)*(Z)*(Z),
+    (z1,z2,z3,z4,z5,z6,z7,z8) = (b, n, z, false, 2, i1, (2, 3, 2), (i1, i2));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::true_kw:ValueProcessor)
+ |       `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ |   +-(language::name:z:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:1:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i1:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i2:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:z1:NameProcessor)
+     |   +-(language::name:z2:NameProcessor)
+     |   +-(language::name:z3:NameProcessor)
+     |   +-(language::name:z4:NameProcessor)
+     |   +-(language::name:z5:NameProcessor)
+     |   +-(language::name:z6:NameProcessor)
+     |   +-(language::name:z7:NameProcessor)
+     |   `-(language::name:z8:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:b:NameProcessor)
+         +-(language::name:n:NameProcessor)
+         +-(language::name:z:NameProcessor)
+         +-(language::false_kw:ValueProcessor)
+         +-(language::integer:2:ValueProcessor)
+         +-(language::name:i1:NameProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::integer:2:ValueProcessor)
+         |   +-(language::integer:3:ValueProcessor)
+         |   `-(language::integer:2:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::name:i1:NameProcessor)
+             `-(language::name:i2:NameProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of R")
+      {
+        std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let r:(R), r = (1.2, 3.3, 2.4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) : (R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R),
+    (r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) = (b, n, z, r, true, 2, i1, 2.3, (2, 3, 2), (i1, i2), (2.2, 1.4));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::true_kw:ValueProcessor)
+ |       `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ |   +-(language::name:z:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:1:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+ |   +-(language::name:r:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::real:1.2:ValueProcessor)
+ |       +-(language::real:3.3:ValueProcessor)
+ |       `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i1:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i2:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:r1:NameProcessor)
+     |   +-(language::name:r2:NameProcessor)
+     |   +-(language::name:r3:NameProcessor)
+     |   +-(language::name:r4:NameProcessor)
+     |   +-(language::name:r5:NameProcessor)
+     |   +-(language::name:r6:NameProcessor)
+     |   +-(language::name:r7:NameProcessor)
+     |   +-(language::name:r8:NameProcessor)
+     |   +-(language::name:r9:NameProcessor)
+     |   +-(language::name:r10:NameProcessor)
+     |   `-(language::name:r11:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:b:NameProcessor)
+         +-(language::name:n:NameProcessor)
+         +-(language::name:z:NameProcessor)
+         +-(language::name:r:NameProcessor)
+         +-(language::true_kw:ValueProcessor)
+         +-(language::integer:2:ValueProcessor)
+         +-(language::name:i1:NameProcessor)
+         +-(language::real:2.3:ValueProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::integer:2:ValueProcessor)
+         |   +-(language::integer:3:ValueProcessor)
+         |   `-(language::integer:2:ValueProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::name:i1:NameProcessor)
+         |   `-(language::name:i2:NameProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::real:2.2:ValueProcessor)
+             `-(language::real:1.4:ValueProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of string")
+      {
+        std::string_view data = R"(
+import utils;
+
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let r:(R), r = (1.2, 3.3, 2.4);
+let s:(string), s = ("foo", "bar");
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13):
+       (string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string),
+    (s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13)
+       = (b, n, z, r, s, 2, i1, 2.3, "foobar", (2, 3, 2), (i1, i2), (2.2, 1.4), ("hello", "world"));
+
+let v1:(R^1), v1 = (2, [3], [5]);
+let v2:(R^2), v2 = ([2,3], [3,5]);
+let v3:(R^3), v3 = ([2,2,3], 0, [1,3,5]);
+let A1:(R^1x1), A1 = (2, [[3]]);
+let A2:(R^2x2), A2 = ([[2,3], [3,5]],0);
+let A3:(R^3x3), A3 = ([[2,2,3], [1,2,7], [1,3,5]], [[1,3,2], [6,3,5], [3,2,-1]]);
+let (t1,t2,t3,t4,t5,t6,t7,t8,t9,t10):
+       (string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string),
+    (t1,t2,t3,t4,t5,t6,t7,t8,t9,t10)
+      = (v1, v2, v3, A1, A2, A3, [[0]], [2,3], [[1,2],[3,4]], ([1,2,3], [2,3,1]));
+
+let (u1,u2,u3,u4): (string)*(string)*(string)*(string),
+    (u1,u2,u3,u4) = (true, [1], [1,2,3], [[1,2,3],[4,5,6],[7,8,9]]);
+)";
+
+        std::string result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::true_kw:ValueProcessor)
+ |       `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ |   +-(language::name:z:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:1:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+ |   +-(language::name:r:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::real:1.2:ValueProcessor)
+ |       +-(language::real:3.3:ValueProcessor)
+ |       `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<)" +
+                             demangled_stdstring + R"( >)
+ |   +-(language::name:s:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::literal:"foo":ValueProcessor)
+ |       `-(language::literal:"bar":ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i1:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i2:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ |   +-(language::name_list:FakeProcessor)
+ |   |   +-(language::name:s1:NameProcessor)
+ |   |   +-(language::name:s2:NameProcessor)
+ |   |   +-(language::name:s3:NameProcessor)
+ |   |   +-(language::name:s4:NameProcessor)
+ |   |   +-(language::name:s5:NameProcessor)
+ |   |   +-(language::name:s6:NameProcessor)
+ |   |   +-(language::name:s7:NameProcessor)
+ |   |   +-(language::name:s8:NameProcessor)
+ |   |   +-(language::name:s9:NameProcessor)
+ |   |   +-(language::name:s10:NameProcessor)
+ |   |   +-(language::name:s11:NameProcessor)
+ |   |   +-(language::name:s12:NameProcessor)
+ |   |   `-(language::name:s13:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::name:b:NameProcessor)
+ |       +-(language::name:n:NameProcessor)
+ |       +-(language::name:z:NameProcessor)
+ |       +-(language::name:r:NameProcessor)
+ |       +-(language::name:s:NameProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       +-(language::name:i1:NameProcessor)
+ |       +-(language::real:2.3:ValueProcessor)
+ |       +-(language::literal:"foobar":ValueProcessor)
+ |       +-(language::inner_expression_list:InnerListToVectorProcessor)
+ |       |   +-(language::integer:2:ValueProcessor)
+ |       |   +-(language::integer:3:ValueProcessor)
+ |       |   `-(language::integer:2:ValueProcessor)
+ |       +-(language::inner_expression_list:InnerListToVectorProcessor)
+ |       |   +-(language::name:i1:NameProcessor)
+ |       |   `-(language::name:i2:NameProcessor)
+ |       +-(language::inner_expression_list:InnerListToVectorProcessor)
+ |       |   +-(language::real:2.2:ValueProcessor)
+ |       |   `-(language::real:1.4:ValueProcessor)
+ |       `-(language::inner_expression_list:InnerListToVectorProcessor)
+ |           +-(language::literal:"hello":ValueProcessor)
+ |           `-(language::literal:"world":ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<1ul, double> >)
+ |   +-(language::name:v1:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ |       |   `-(language::integer:3:ValueProcessor)
+ |       `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ |           `-(language::integer:5:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<2ul, double> >)
+ |   +-(language::name:v2:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ |       |   +-(language::integer:2:ValueProcessor)
+ |       |   `-(language::integer:3:ValueProcessor)
+ |       `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ |           +-(language::integer:3:ValueProcessor)
+ |           `-(language::integer:5:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<3ul, double> >)
+ |   +-(language::name:v3:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ |       |   +-(language::integer:2:ValueProcessor)
+ |       |   +-(language::integer:2:ValueProcessor)
+ |       |   `-(language::integer:3:ValueProcessor)
+ |       +-(language::integer:0:ValueProcessor)
+ |       `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ |           +-(language::integer:1:ValueProcessor)
+ |           +-(language::integer:3:ValueProcessor)
+ |           `-(language::integer:5:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<1ul, 1ul, double> >)
+ |   +-(language::name:A1:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       `-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ |           `-(language::row_expression:FakeProcessor)
+ |               `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<2ul, 2ul, double> >)
+ |   +-(language::name:A2:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ |       |   +-(language::row_expression:FakeProcessor)
+ |       |   |   +-(language::integer:2:ValueProcessor)
+ |       |   |   `-(language::integer:3:ValueProcessor)
+ |       |   `-(language::row_expression:FakeProcessor)
+ |       |       +-(language::integer:3:ValueProcessor)
+ |       |       `-(language::integer:5:ValueProcessor)
+ |       `-(language::integer:0:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<3ul, 3ul, double> >)
+ |   +-(language::name:A3:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ |       |   +-(language::row_expression:FakeProcessor)
+ |       |   |   +-(language::integer:2:ValueProcessor)
+ |       |   |   +-(language::integer:2:ValueProcessor)
+ |       |   |   `-(language::integer:3:ValueProcessor)
+ |       |   +-(language::row_expression:FakeProcessor)
+ |       |   |   +-(language::integer:1:ValueProcessor)
+ |       |   |   +-(language::integer:2:ValueProcessor)
+ |       |   |   `-(language::integer:7:ValueProcessor)
+ |       |   `-(language::row_expression:FakeProcessor)
+ |       |       +-(language::integer:1:ValueProcessor)
+ |       |       +-(language::integer:3:ValueProcessor)
+ |       |       `-(language::integer:5:ValueProcessor)
+ |       `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ |           +-(language::row_expression:FakeProcessor)
+ |           |   +-(language::integer:1:ValueProcessor)
+ |           |   +-(language::integer:3:ValueProcessor)
+ |           |   `-(language::integer:2:ValueProcessor)
+ |           +-(language::row_expression:FakeProcessor)
+ |           |   +-(language::integer:6:ValueProcessor)
+ |           |   +-(language::integer:3:ValueProcessor)
+ |           |   `-(language::integer:5:ValueProcessor)
+ |           `-(language::row_expression:FakeProcessor)
+ |               +-(language::integer:3:ValueProcessor)
+ |               +-(language::integer:2:ValueProcessor)
+ |               `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+ |                   `-(language::integer:1:ValueProcessor)
+ +-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ |   +-(language::name_list:FakeProcessor)
+ |   |   +-(language::name:t1:NameProcessor)
+ |   |   +-(language::name:t2:NameProcessor)
+ |   |   +-(language::name:t3:NameProcessor)
+ |   |   +-(language::name:t4:NameProcessor)
+ |   |   +-(language::name:t5:NameProcessor)
+ |   |   +-(language::name:t6:NameProcessor)
+ |   |   +-(language::name:t7:NameProcessor)
+ |   |   +-(language::name:t8:NameProcessor)
+ |   |   +-(language::name:t9:NameProcessor)
+ |   |   `-(language::name:t10:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::name:v1:NameProcessor)
+ |       +-(language::name:v2:NameProcessor)
+ |       +-(language::name:v3:NameProcessor)
+ |       +-(language::name:A1:NameProcessor)
+ |       +-(language::name:A2:NameProcessor)
+ |       +-(language::name:A3:NameProcessor)
+ |       +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ |       |   `-(language::row_expression:FakeProcessor)
+ |       |       `-(language::integer:0:ValueProcessor)
+ |       +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ |       |   +-(language::integer:2:ValueProcessor)
+ |       |   `-(language::integer:3:ValueProcessor)
+ |       +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ |       |   +-(language::row_expression:FakeProcessor)
+ |       |   |   +-(language::integer:1:ValueProcessor)
+ |       |   |   `-(language::integer:2:ValueProcessor)
+ |       |   `-(language::row_expression:FakeProcessor)
+ |       |       +-(language::integer:3:ValueProcessor)
+ |       |       `-(language::integer:4:ValueProcessor)
+ |       `-(language::inner_expression_list:InnerListToVectorProcessor)
+ |           +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ |           |   +-(language::integer:1:ValueProcessor)
+ |           |   +-(language::integer:2:ValueProcessor)
+ |           |   `-(language::integer:3:ValueProcessor)
+ |           `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ |               +-(language::integer:2:ValueProcessor)
+ |               +-(language::integer:3:ValueProcessor)
+ |               `-(language::integer:1:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:u1:NameProcessor)
+     |   +-(language::name:u2:NameProcessor)
+     |   +-(language::name:u3:NameProcessor)
+     |   `-(language::name:u4:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::true_kw:ValueProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+         |   `-(language::integer:1:ValueProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+         |   +-(language::integer:1:ValueProcessor)
+         |   +-(language::integer:2:ValueProcessor)
+         |   `-(language::integer:3:ValueProcessor)
+         `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+             +-(language::row_expression:FakeProcessor)
+             |   +-(language::integer:1:ValueProcessor)
+             |   +-(language::integer:2:ValueProcessor)
+             |   `-(language::integer:3:ValueProcessor)
+             +-(language::row_expression:FakeProcessor)
+             |   +-(language::integer:4:ValueProcessor)
+             |   +-(language::integer:5:ValueProcessor)
+             |   `-(language::integer:6:ValueProcessor)
+             `-(language::row_expression:FakeProcessor)
+                 +-(language::integer:7:ValueProcessor)
+                 +-(language::integer:8:ValueProcessor)
+                 `-(language::integer:9:ValueProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of R^1")
+      {
+        std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let r:(R), r = (1.2, 3.3, 2.4);
+let X:(R^1), X = (1.2, [3.3], 2.4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14) : (R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1),
+    (X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14) = (b, n, z, r, true, 2, i1, 2.3, [1.2], X, (2, 3, 2), (i1, i2), (2.2, 1.4), ([1], [2]));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::true_kw:ValueProcessor)
+ |       `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ |   +-(language::name:z:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:1:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+ |   +-(language::name:r:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::real:1.2:ValueProcessor)
+ |       +-(language::real:3.3:ValueProcessor)
+ |       `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<1ul, double> >)
+ |   +-(language::name:X:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::real:1.2:ValueProcessor)
+ |       +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ |       |   `-(language::real:3.3:ValueProcessor)
+ |       `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i1:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i2:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:X1:NameProcessor)
+     |   +-(language::name:X2:NameProcessor)
+     |   +-(language::name:X3:NameProcessor)
+     |   +-(language::name:X4:NameProcessor)
+     |   +-(language::name:X5:NameProcessor)
+     |   +-(language::name:X6:NameProcessor)
+     |   +-(language::name:X7:NameProcessor)
+     |   +-(language::name:X8:NameProcessor)
+     |   +-(language::name:X9:NameProcessor)
+     |   +-(language::name:X10:NameProcessor)
+     |   +-(language::name:X11:NameProcessor)
+     |   +-(language::name:X12:NameProcessor)
+     |   +-(language::name:X13:NameProcessor)
+     |   `-(language::name:X14:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:b:NameProcessor)
+         +-(language::name:n:NameProcessor)
+         +-(language::name:z:NameProcessor)
+         +-(language::name:r:NameProcessor)
+         +-(language::true_kw:ValueProcessor)
+         +-(language::integer:2:ValueProcessor)
+         +-(language::name:i1:NameProcessor)
+         +-(language::real:2.3:ValueProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+         |   `-(language::real:1.2:ValueProcessor)
+         +-(language::name:X:NameProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::integer:2:ValueProcessor)
+         |   +-(language::integer:3:ValueProcessor)
+         |   `-(language::integer:2:ValueProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::name:i1:NameProcessor)
+         |   `-(language::name:i2:NameProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::real:2.2:ValueProcessor)
+         |   `-(language::real:1.4:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+             |   `-(language::integer:1:ValueProcessor)
+             `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+                 `-(language::integer:2:ValueProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of R^2")
+      {
+        std::string_view data = R"(
+let X:(R^2), X = ([1.2,2], 0, [2.4, 2]);
+let (X1,X2,X3) : (R^2)*(R^2)*(R^2), (X1,X2,X3) = (X, [1,2], ([0,2], [1,0]));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<2ul, double> >)
+ |   +-(language::name:X:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ |       |   +-(language::real:1.2:ValueProcessor)
+ |       |   `-(language::integer:2:ValueProcessor)
+ |       +-(language::integer:0:ValueProcessor)
+ |       `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ |           +-(language::real:2.4:ValueProcessor)
+ |           `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:X1:NameProcessor)
+     |   +-(language::name:X2:NameProcessor)
+     |   `-(language::name:X3:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:X:NameProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+         |   +-(language::integer:1:ValueProcessor)
+         |   `-(language::integer:2:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+             |   +-(language::integer:0:ValueProcessor)
+             |   `-(language::integer:2:ValueProcessor)
+             `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+                 +-(language::integer:1:ValueProcessor)
+                 `-(language::integer:0:ValueProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of R^3")
+      {
+        std::string_view data = R"(
+let X:(R^3), X = ([1.2,2,4.2], 0, [2.4, 1, 2]);
+let (X1,X2,X3) : (R^3)*(R^3)*(R^3), (X1,X2,X3) = (X, [2,1,4], ([0,2,1.2], [1,2.1,3.1]));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<3ul, double> >)
+ |   +-(language::name:X:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ |       |   +-(language::real:1.2:ValueProcessor)
+ |       |   +-(language::integer:2:ValueProcessor)
+ |       |   `-(language::real:4.2:ValueProcessor)
+ |       +-(language::integer:0:ValueProcessor)
+ |       `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ |           +-(language::real:2.4:ValueProcessor)
+ |           +-(language::integer:1:ValueProcessor)
+ |           `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:X1:NameProcessor)
+     |   +-(language::name:X2:NameProcessor)
+     |   `-(language::name:X3:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:X:NameProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+         |   +-(language::integer:2:ValueProcessor)
+         |   +-(language::integer:1:ValueProcessor)
+         |   `-(language::integer:4:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+             |   +-(language::integer:0:ValueProcessor)
+             |   +-(language::integer:2:ValueProcessor)
+             |   `-(language::real:1.2:ValueProcessor)
+             `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+                 +-(language::integer:1:ValueProcessor)
+                 +-(language::real:2.1:ValueProcessor)
+                 `-(language::real:3.1:ValueProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of R^1x1")
+      {
+        std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let r:(R), r = (1.2, 3.3, 2.4);
+let A:(R^1x1), A = (1.2, [[3.3]], 2.4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14) : (R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1),
+    (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14) = (b, n, z, r, true, 2, i1, 2.3, [[1.2]], A, (2, 3, 2), (i1, i2), (2.2, 1.4), ([[1]], [[2]]));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::true_kw:ValueProcessor)
+ |       `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:2:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ |   +-(language::name:z:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:1:ValueProcessor)
+ |       +-(language::integer:3:ValueProcessor)
+ |       `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+ |   +-(language::name:r:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::real:1.2:ValueProcessor)
+ |       +-(language::real:3.3:ValueProcessor)
+ |       `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<1ul, 1ul, double> >)
+ |   +-(language::name:A:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::real:1.2:ValueProcessor)
+ |       +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ |       |   `-(language::row_expression:FakeProcessor)
+ |       |       `-(language::real:3.3:ValueProcessor)
+ |       `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i1:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:i2:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:A1:NameProcessor)
+     |   +-(language::name:A2:NameProcessor)
+     |   +-(language::name:A3:NameProcessor)
+     |   +-(language::name:A4:NameProcessor)
+     |   +-(language::name:A5:NameProcessor)
+     |   +-(language::name:A6:NameProcessor)
+     |   +-(language::name:A7:NameProcessor)
+     |   +-(language::name:A8:NameProcessor)
+     |   +-(language::name:A9:NameProcessor)
+     |   +-(language::name:A10:NameProcessor)
+     |   +-(language::name:A11:NameProcessor)
+     |   +-(language::name:A12:NameProcessor)
+     |   +-(language::name:A13:NameProcessor)
+     |   `-(language::name:A14:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:b:NameProcessor)
+         +-(language::name:n:NameProcessor)
+         +-(language::name:z:NameProcessor)
+         +-(language::name:r:NameProcessor)
+         +-(language::true_kw:ValueProcessor)
+         +-(language::integer:2:ValueProcessor)
+         +-(language::name:i1:NameProcessor)
+         +-(language::real:2.3:ValueProcessor)
+         +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+         |   `-(language::row_expression:FakeProcessor)
+         |       `-(language::real:1.2:ValueProcessor)
+         +-(language::name:A:NameProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::integer:2:ValueProcessor)
+         |   +-(language::integer:3:ValueProcessor)
+         |   `-(language::integer:2:ValueProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::name:i1:NameProcessor)
+         |   `-(language::name:i2:NameProcessor)
+         +-(language::inner_expression_list:InnerListToVectorProcessor)
+         |   +-(language::real:2.2:ValueProcessor)
+         |   `-(language::real:1.4:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+             |   `-(language::row_expression:FakeProcessor)
+             |       `-(language::integer:1:ValueProcessor)
+             `-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+                 `-(language::row_expression:FakeProcessor)
+                     `-(language::integer:2:ValueProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+
+      SECTION("tuple of embedded data")
+      {
+        std::string_view data = R"(
+let b: builtin_t, b = b;
+let tb: (builtin_t), tb = (b,b);
+let (tb1,tb2,tb3): (builtin_t)*(builtin_t)*(builtin_t), (tb1,tb2,tb3) = (b,tb, (b,b,b));
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, EmbeddedData, EmbeddedData>)
+ |   +-(language::name:b:NameProcessor)
+ |   `-(language::name:b:NameProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<EmbeddedData>)
+ |   +-(language::name:tb:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::name:b:NameProcessor)
+ |       `-(language::name:b:NameProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:tb1:NameProcessor)
+     |   +-(language::name:tb2:NameProcessor)
+     |   `-(language::name:tb3:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:b:NameProcessor)
+         +-(language::name:tb:NameProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::name:b:NameProcessor)
+             +-(language::name:b:NameProcessor)
+             `-(language::name:b:NameProcessor)
+)";
+
+        CHECK_AST(data, result);
+      }
+    }
+
+    SECTION("tuple of R^2x2")
+    {
+      std::string_view data = R"(
+let A:(R^2x2), A = ([[1.2,2],[2.1,1]], 0, [[1.4, 2],[2.4, 2]]);
+let (A1,A2,A3) : (R^2x2)*(R^2x2)*(R^2x2), (A1,A2,A3) = (A, [[1,2],[4,1]], ([[0,2], [1,0]], [[1.3,2], [3,1]]));
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<2ul, 2ul, double> >)
+ |   +-(language::name:A:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ |       |   +-(language::row_expression:FakeProcessor)
+ |       |   |   +-(language::real:1.2:ValueProcessor)
+ |       |   |   `-(language::integer:2:ValueProcessor)
+ |       |   `-(language::row_expression:FakeProcessor)
+ |       |       +-(language::real:2.1:ValueProcessor)
+ |       |       `-(language::integer:1:ValueProcessor)
+ |       +-(language::integer:0:ValueProcessor)
+ |       `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ |           +-(language::row_expression:FakeProcessor)
+ |           |   +-(language::real:1.4:ValueProcessor)
+ |           |   `-(language::integer:2:ValueProcessor)
+ |           `-(language::row_expression:FakeProcessor)
+ |               +-(language::real:2.4:ValueProcessor)
+ |               `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:A1:NameProcessor)
+     |   +-(language::name:A2:NameProcessor)
+     |   `-(language::name:A3:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:A:NameProcessor)
+         +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+         |   +-(language::row_expression:FakeProcessor)
+         |   |   +-(language::integer:1:ValueProcessor)
+         |   |   `-(language::integer:2:ValueProcessor)
+         |   `-(language::row_expression:FakeProcessor)
+         |       +-(language::integer:4:ValueProcessor)
+         |       `-(language::integer:1:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+             |   +-(language::row_expression:FakeProcessor)
+             |   |   +-(language::integer:0:ValueProcessor)
+             |   |   `-(language::integer:2:ValueProcessor)
+             |   `-(language::row_expression:FakeProcessor)
+             |       +-(language::integer:1:ValueProcessor)
+             |       `-(language::integer:0:ValueProcessor)
+             `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+                 +-(language::row_expression:FakeProcessor)
+                 |   +-(language::real:1.3:ValueProcessor)
+                 |   `-(language::integer:2:ValueProcessor)
+                 `-(language::row_expression:FakeProcessor)
+                     +-(language::integer:3:ValueProcessor)
+                     `-(language::integer:1:ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("tuple of R^3x3")
+    {
+      std::string_view data = R"(
+let A:(R^3x3), A = ([[1.2,2,1],[2.1,1,3],[1.2,1.2,3.2]], 0, [[1.4, 2, 1],[2.4, 0, 2],[2.1, 0.1, 3.2]]);
+let (A1,A2,A3) : (R^3x3)*(R^3x3)*(R^3x3), (A1,A2,A3) = (A, [[1,2,3],[1.2,3.1,1.8],[2,4,1]], ([[0,2,1], [2,1,0], [0.2,1,3]], [[1.3,2,1], [0.3,3,1], [0.1,2,4.3]]));
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<3ul, 3ul, double> >)
+ |   +-(language::name:A:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ |       |   +-(language::row_expression:FakeProcessor)
+ |       |   |   +-(language::real:1.2:ValueProcessor)
+ |       |   |   +-(language::integer:2:ValueProcessor)
+ |       |   |   `-(language::integer:1:ValueProcessor)
+ |       |   +-(language::row_expression:FakeProcessor)
+ |       |   |   +-(language::real:2.1:ValueProcessor)
+ |       |   |   +-(language::integer:1:ValueProcessor)
+ |       |   |   `-(language::integer:3:ValueProcessor)
+ |       |   `-(language::row_expression:FakeProcessor)
+ |       |       +-(language::real:1.2:ValueProcessor)
+ |       |       +-(language::real:1.2:ValueProcessor)
+ |       |       `-(language::real:3.2:ValueProcessor)
+ |       +-(language::integer:0:ValueProcessor)
+ |       `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ |           +-(language::row_expression:FakeProcessor)
+ |           |   +-(language::real:1.4:ValueProcessor)
+ |           |   +-(language::integer:2:ValueProcessor)
+ |           |   `-(language::integer:1:ValueProcessor)
+ |           +-(language::row_expression:FakeProcessor)
+ |           |   +-(language::real:2.4:ValueProcessor)
+ |           |   +-(language::integer:0:ValueProcessor)
+ |           |   `-(language::integer:2:ValueProcessor)
+ |           `-(language::row_expression:FakeProcessor)
+ |               +-(language::real:2.1:ValueProcessor)
+ |               +-(language::real:0.1:ValueProcessor)
+ |               `-(language::real:3.2:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:A1:NameProcessor)
+     |   +-(language::name:A2:NameProcessor)
+     |   `-(language::name:A3:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::name:A:NameProcessor)
+         +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+         |   +-(language::row_expression:FakeProcessor)
+         |   |   +-(language::integer:1:ValueProcessor)
+         |   |   +-(language::integer:2:ValueProcessor)
+         |   |   `-(language::integer:3:ValueProcessor)
+         |   +-(language::row_expression:FakeProcessor)
+         |   |   +-(language::real:1.2:ValueProcessor)
+         |   |   +-(language::real:3.1:ValueProcessor)
+         |   |   `-(language::real:1.8:ValueProcessor)
+         |   `-(language::row_expression:FakeProcessor)
+         |       +-(language::integer:2:ValueProcessor)
+         |       +-(language::integer:4:ValueProcessor)
+         |       `-(language::integer:1:ValueProcessor)
+         `-(language::inner_expression_list:InnerListToVectorProcessor)
+             +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+             |   +-(language::row_expression:FakeProcessor)
+             |   |   +-(language::integer:0:ValueProcessor)
+             |   |   +-(language::integer:2:ValueProcessor)
+             |   |   `-(language::integer:1:ValueProcessor)
+             |   +-(language::row_expression:FakeProcessor)
+             |   |   +-(language::integer:2:ValueProcessor)
+             |   |   +-(language::integer:1:ValueProcessor)
+             |   |   `-(language::integer:0:ValueProcessor)
+             |   `-(language::row_expression:FakeProcessor)
+             |       +-(language::real:0.2:ValueProcessor)
+             |       +-(language::integer:1:ValueProcessor)
+             |       `-(language::integer:3:ValueProcessor)
+             `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+                 +-(language::row_expression:FakeProcessor)
+                 |   +-(language::real:1.3:ValueProcessor)
+                 |   +-(language::integer:2:ValueProcessor)
+                 |   `-(language::integer:1:ValueProcessor)
+                 +-(language::row_expression:FakeProcessor)
+                 |   +-(language::real:0.3:ValueProcessor)
+                 |   +-(language::integer:3:ValueProcessor)
+                 |   `-(language::integer:1:ValueProcessor)
+                 `-(language::row_expression:FakeProcessor)
+                     +-(language::real:0.1:ValueProcessor)
+                     +-(language::integer:2:ValueProcessor)
+                     `-(language::real:4.3:ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
     SECTION("from function")
     {
       std::string_view data = R"(
@@ -371,10 +1384,10 @@ let  (s,r): string*string, (s,r) = ("foo","bar");
       CHECK_AST(data, result);
     }
 
-    SECTION("string with conversion")
+    SECTION("string with scalar conversions")
     {
       std::string_view data = R"(
-let n:N, n =2;
+let n:N, n = 2;
 let  (r,s,t,u) : string*string*string*string,
      (r,s,t,u) = (3.2, -2, true, n);
 )";
@@ -401,6 +1414,80 @@ let  (r,s,t,u) : string*string*string*string,
       CHECK_AST(data, result);
     }
 
+    SECTION("string with vector conversions")
+    {
+      std::string_view data = R"(
+let  (r,s,t) : string*string*string,
+     (r,s,t) = ([3.2], [-2, 3], [1,3,2]);
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:r:NameProcessor)
+     |   +-(language::name:s:NameProcessor)
+     |   `-(language::name:t:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+         |   `-(language::real:3.2:ValueProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+         |   +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+         |   |   `-(language::integer:2:ValueProcessor)
+         |   `-(language::integer:3:ValueProcessor)
+         `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+             +-(language::integer:1:ValueProcessor)
+             +-(language::integer:3:ValueProcessor)
+             `-(language::integer:2:ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("string with matrix conversions")
+    {
+      std::string_view data = R"(
+let  (r,s,t) : string*string*string,
+     (r,s,t) = ([[3.2]], [[1, 2],[-2, 3]], [[1,3,2],[2,1,3],[4,1,2]]);
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+     +-(language::name_list:FakeProcessor)
+     |   +-(language::name:r:NameProcessor)
+     |   +-(language::name:s:NameProcessor)
+     |   `-(language::name:t:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+         |   `-(language::row_expression:FakeProcessor)
+         |       `-(language::real:3.2:ValueProcessor)
+         +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+         |   +-(language::row_expression:FakeProcessor)
+         |   |   +-(language::integer:1:ValueProcessor)
+         |   |   `-(language::integer:2:ValueProcessor)
+         |   `-(language::row_expression:FakeProcessor)
+         |       +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+         |       |   `-(language::integer:2:ValueProcessor)
+         |       `-(language::integer:3:ValueProcessor)
+         `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+             +-(language::row_expression:FakeProcessor)
+             |   +-(language::integer:1:ValueProcessor)
+             |   +-(language::integer:3:ValueProcessor)
+             |   `-(language::integer:2:ValueProcessor)
+             +-(language::row_expression:FakeProcessor)
+             |   +-(language::integer:2:ValueProcessor)
+             |   +-(language::integer:1:ValueProcessor)
+             |   `-(language::integer:3:ValueProcessor)
+             `-(language::row_expression:FakeProcessor)
+                 +-(language::integer:4:ValueProcessor)
+                 +-(language::integer:1:ValueProcessor)
+                 `-(language::integer:2:ValueProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
     SECTION("embedded data")
     {
       std::string_view data = R"(
diff --git a/tests/test_AffectationToStringProcessor.cpp b/tests/test_AffectationToStringProcessor.cpp
index d65a18a2e106f9afbbee3ca580255182ecf880e3..040692a9ea79e9b7cd4f12b310f57d58040f5b68 100644
--- a/tests/test_AffectationToStringProcessor.cpp
+++ b/tests/test_AffectationToStringProcessor.cpp
@@ -56,7 +56,11 @@ TEST_CASE("ASTAffectationToStringProcessor", "[language]")
     CHECK_AFFECTATION_RESULT(R"(let s : string; s = "foo";)", "s", std::string("foo"));
     CHECK_AFFECTATION_RESULT(R"(let n : N, n = 2; let s : string; s = n;)", "s", std::to_string(2ul));
     CHECK_AFFECTATION_RESULT(R"(let s : string; s = -1;)", "s", std::to_string(-1l));
-    CHECK_AFFECTATION_RESULT(R"(let s : string; s = true;)", "s", std::to_string(true));
+    {
+      std::ostringstream os;
+      os << std::boolalpha << true;
+      CHECK_AFFECTATION_RESULT(R"(let s : string; s = true;)", "s", os.str());
+    }
     CHECK_AFFECTATION_RESULT(R"(let s : string; s = 2.3;)", "s", std::to_string(2.3));
     {
       std::ostringstream os;
@@ -81,8 +85,11 @@ TEST_CASE("ASTAffectationToStringProcessor", "[language]")
     CHECK_AFFECTATION_RESULT(R"(let n : N, n = 2; let s : string, s = "foo"; s += n;)", "s",
                              (std::string("foo") + std::to_string(2ul)));
     CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += -1;)", "s", (std::string("foo") + std::to_string(-1l)));
-    CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += true;)", "s",
-                             (std::string("foo") + std::to_string(true)));
+    {
+      std::ostringstream os;
+      os << "foo" << std::boolalpha << true;
+      CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += true;)", "s", os.str());
+    }
     CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += 2.3;)", "s",
                              (std::string("foo") + std::to_string(2.3)));
     {