diff --git a/tests/test_ASTNodeAffectationExpressionBuilder.cpp b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
index 7055452b2b3e99f19fd2ec267c70477569297d4d..57b8290ec489223498b67ab40dad50f86bb32a0a 100644
--- a/tests/test_ASTNodeAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
@@ -179,9 +179,9 @@ TEST_CASE("ASTNodeAffectationExpressionBuilder", "[language]")
 
   SECTION("Affectations")
   {
-    SECTION("boolean affectation")
+    SECTION("-> B")
     {
-      SECTION("B <- B")
+      SECTION("B -> B")
       {
         std::string_view data = R"(
 let b:B, b=true;
@@ -198,9 +198,9 @@ let b:B, b=true;
       }
     }
 
-    SECTION("unsigned integer affectation")
+    SECTION("-> N")
     {
-      SECTION("N <- B")
+      SECTION("B -> N")
       {
         std::string_view data = R"(
 let n:N, n=true;
@@ -216,7 +216,7 @@ let n:N, n=true;
         CHECK_AST(data, result);
       }
 
-      SECTION("N <- N")
+      SECTION("N -> N")
       {
         std::string_view data = R"(
 let m : N; let n:N, n=m;
@@ -232,7 +232,7 @@ let m : N; let n:N, n=m;
         CHECK_AST(data, result);
       }
 
-      SECTION("N <- Z")
+      SECTION("Z -> N")
       {
         std::string_view data = R"(
 let z:Z; let n :N, n=z;
@@ -249,9 +249,9 @@ let z:Z; let n :N, n=z;
       }
     }
 
-    SECTION("integer affectation")
+    SECTION("-> Z")
     {
-      SECTION("Z <- B")
+      SECTION("B -> Z")
       {
         std::string_view data = R"(
 let z : Z, z=true;
@@ -267,7 +267,7 @@ let z : Z, z=true;
         CHECK_AST(data, result);
       }
 
-      SECTION("Z <- N")
+      SECTION("N -> Z")
       {
         std::string_view data = R"(
 let m : N; let z : Z, z=m;
@@ -283,7 +283,7 @@ let m : N; let z : Z, z=m;
         CHECK_AST(data, result);
       }
 
-      SECTION("Z <- Z")
+      SECTION("Z -> Z")
       {
         std::string_view data = R"(
 let q : Z; let z : Z, z=q;
@@ -300,9 +300,9 @@ let q : Z; let z : Z, z=q;
       }
     }
 
-    SECTION("double affectation")
+    SECTION("-> R")
     {
-      SECTION("R <- B")
+      SECTION("B -> R")
       {
         std::string_view data = R"(
 let r : R, r=true;
@@ -318,7 +318,7 @@ let r : R, r=true;
         CHECK_AST(data, result);
       }
 
-      SECTION("R <- N")
+      SECTION("N -> R")
       {
         std::string_view data = R"(
 let m : N; let r : R, r=m;
@@ -334,7 +334,7 @@ let m : N; let r : R, r=m;
         CHECK_AST(data, result);
       }
 
-      SECTION("R <- Z")
+      SECTION("Z -> R")
       {
         std::string_view data = R"(
 let z : Z; let r : R, r=z;
@@ -350,7 +350,7 @@ let z : Z; let r : R, r=z;
         CHECK_AST(data, result);
       }
 
-      SECTION("R <- R")
+      SECTION("R -> R")
       {
         std::string_view data = R"(
 let s : R; let r : R, r=s;
@@ -367,9 +367,9 @@ let s : R; let r : R, r=s;
       }
     }
 
-    SECTION("R^d affectation")
+    SECTION("-> R^d")
     {
-      SECTION("R^1 <- R^1")
+      SECTION("R^1 -> R^1")
       {
         std::string_view data = R"(
 let x : R^1;
@@ -386,7 +386,7 @@ let y : R^1, y = x;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^1 <- R")
+      SECTION("R -> R^1")
       {
         std::string_view data = R"(
 let x : R^1, x = 1.3;
@@ -402,7 +402,7 @@ let x : R^1, x = 1.3;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^1 <- Z")
+      SECTION("Z -> R^1")
       {
         std::string_view data = R"(
 let x : R^1, x = -1;
@@ -419,7 +419,7 @@ let x : R^1, x = -1;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^1 <- N")
+      SECTION("N -> R^1")
       {
         std::string_view data = R"(
 let n : N;
@@ -436,7 +436,7 @@ let x : R^1, x = n;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^1 <- B")
+      SECTION("B -> R^1")
       {
         std::string_view data = R"(
 let b : B;
@@ -453,7 +453,7 @@ let x : R^1, x = b;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^1 <- 0")
+      SECTION("'0' -> R^1")
       {
         std::string_view data = R"(
 let x : R^1, x = 0;
@@ -469,7 +469,7 @@ let x : R^1, x = 0;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^2 <- R^2")
+      SECTION("R^2 -> R^2 [variable]")
       {
         std::string_view data = R"(
 let x : R^2;
@@ -486,7 +486,7 @@ let y : R^2, y = x;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^2 <- value")
+      SECTION("R^2 -> R^2 [value]")
       {
         std::string_view data = R"(
 let y : R^2, y = [0,1];
@@ -504,7 +504,7 @@ let y : R^2, y = [0,1];
         CHECK_AST(data, result);
       }
 
-      SECTION("R^2 <- 0")
+      SECTION("'0' -> R^2")
       {
         std::string_view data = R"(
 let x : R^2, x = 0;
@@ -520,7 +520,7 @@ let x : R^2, x = 0;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^3 <- R^3")
+      SECTION("R^3 -> R^3")
       {
         std::string_view data = R"(
 let x : R^3;
@@ -537,7 +537,7 @@ let y : R^3, y = x;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^3 <- 0")
+      SECTION("'0' -> R^3")
       {
         std::string_view data = R"(
 let x : R^3, x = 0;
@@ -553,7 +553,7 @@ let x : R^3, x = 0;
         CHECK_AST(data, result);
       }
 
-      SECTION("R^3 <- value")
+      SECTION("R^3 -> R^3 [value]")
       {
         std::string_view data = R"(
 let y : R^3, y = [1,2,3];
@@ -573,9 +573,9 @@ let y : R^3, y = [1,2,3];
       }
     }
 
-    SECTION("string affectation")
+    SECTION("-> string")
     {
-      SECTION("string <- B")
+      SECTION("B -> string")
       {
         std::string_view data = R"(
 let s : string, s=true;
@@ -592,7 +592,7 @@ let s : string, s=true;
         CHECK_AST(data, result);
       }
 
-      SECTION("string <- N")
+      SECTION("N -> string")
       {
         std::string_view data = R"(
 let n : N; let s : string, s=n;
@@ -609,7 +609,7 @@ let n : N; let s : string, s=n;
         CHECK_AST(data, result);
       }
 
-      SECTION("string <- Z")
+      SECTION("Z -> string")
       {
         std::string_view data = R"(
 let z : Z; let s : string, s=z;
@@ -627,7 +627,7 @@ let z : Z; let s : string, s=z;
         CHECK_AST(data, result);
       }
 
-      SECTION("string <- R")
+      SECTION("R -> string")
       {
         std::string_view data = R"(
 let r : R; let s : string, s=r;
@@ -645,7 +645,7 @@ let r : R; let s : string, s=r;
         CHECK_AST(data, result);
       }
 
-      SECTION("string <- string")
+      SECTION("string -> string")
       {
         std::string_view data = R"(
 let s : string, s="foo";
@@ -663,9 +663,9 @@ let s : string, s="foo";
       }
     }
 
-    SECTION("type_id affectation")
+    SECTION("-> type_id")
     {
-      SECTION("type_id <- type_id")
+      SECTION("type_id -> type_id")
       {
         std::string_view data = R"(
 let t : builtin_t, t=a;
@@ -682,9 +682,9 @@ let t : builtin_t, t=a;
       }
     }
 
-    SECTION("tuples")
+    SECTION("list -> tuple")
     {
-      SECTION("B tuples")
+      SECTION("-> (B)")
       {
         std::string_view data = R"(
 let t : (B), t = (true, false);
@@ -702,7 +702,7 @@ let t : (B), t = (true, false);
         CHECK_AST(data, result);
       }
 
-      SECTION("N tuples")
+      SECTION("-> (N)")
       {
         std::string_view data = R"(
 let t : (N), t = (1, 2, 3, 5);
@@ -722,7 +722,7 @@ let t : (N), t = (1, 2, 3, 5);
         CHECK_AST(data, result);
       }
 
-      SECTION("Z tuples")
+      SECTION("-> (Z)")
       {
         std::string_view data = R"(
 let n : N, n = 3;
@@ -745,26 +745,31 @@ let t : (Z), t = (2, n, true);
         CHECK_AST(data, result);
       }
 
-      SECTION("R tuples")
+      SECTION("-> (R)")
       {
         std::string_view data = R"(
-let t : (R), t = (2, 3.1, 5);
+let n : N, n = 2;
+let t : (R), t = (n, 3.1, 5, true);
 )";
 
         std::string_view result = R"(
 (root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::integer:2:ValueProcessor)
  `-(language::eq_op:AffectationToTupleFromListProcessor<double>)
      +-(language::name:t:NameProcessor)
      `-(language::expression_list:ASTNodeExpressionListProcessor)
-         +-(language::integer:2:ValueProcessor)
+         +-(language::name:n:NameProcessor)
          +-(language::real:3.1:ValueProcessor)
-         `-(language::integer:5:ValueProcessor)
+         +-(language::integer:5:ValueProcessor)
+         `-(language::true_kw:ValueProcessor)
 )";
 
         CHECK_AST(data, result);
       }
 
-      SECTION("R^d tuples")
+      SECTION("-> (R^d)")
       {
         std::string_view data = R"(
 let a : R^2, a = [2,3.1];
@@ -803,26 +808,128 @@ let t3 : (R^1), t3 = (1, 2.3, 0);
         CHECK_AST(data, result);
       }
 
-      SECTION("string tuples")
+      SECTION("-> (R^dxd)")
       {
         std::string_view data = R"(
-let t : (string), t = ("foo", "bar");
+let a : R^2x2, a = [[2, 5],[2, 3.1]];
+let t1 : (R^2x2), t1 = (a, [[1,2],[5,6]], 0);
+let t2 : (R^3x3), t2 = (0, [[1,2,3],[4,5,6],[7,8,9]]);
+let t3 : (R^1x1), t3 = (1, [[2.3]], 0);
+)";
+
+        std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyMatrix<2ul, 2ul, double>, TinyMatrix<2ul, 2ul, double> >)
+ |   +-(language::name:a:NameProcessor)
+ |   `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ |       +-(language::row_expression:FakeProcessor)
+ |       |   +-(language::integer:2:ValueProcessor)
+ |       |   `-(language::integer:5:ValueProcessor)
+ |       `-(language::row_expression:FakeProcessor)
+ |           +-(language::integer:2:ValueProcessor)
+ |           `-(language::real:3.1:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<2ul, 2ul, double> >)
+ |   +-(language::name:t1: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:5:ValueProcessor)
+ |       |       `-(language::integer:6:ValueProcessor)
+ |       `-(language::integer:0:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<3ul, 3ul, double> >)
+ |   +-(language::name:t2:NameProcessor)
+ |   `-(language::expression_list:ASTNodeExpressionListProcessor)
+ |       +-(language::integer:0: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)
+ `-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<1ul, 1ul, double> >)
+     +-(language::name:t3:NameProcessor)
+     `-(language::expression_list:ASTNodeExpressionListProcessor)
+         +-(language::integer:1:ValueProcessor)
+         +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+         |   `-(language::row_expression:FakeProcessor)
+         |       `-(language::real:2.3:ValueProcessor)
+         `-(language::integer:0:ValueProcessor)
+)";
+        CHECK_AST(data, result);
+      }
+
+      SECTION("-> (string)")
+      {
+        std::string_view data = R"(
+let n : N, n = 3;
+let t : (string), t = ("foo", "bar", n, 1, 1.2,
+                       [1], [1,2], [1,2,3],
+                       [[2]], [[1,2],[3,4]], [[1,2,3],[4,5,6],[7,8,9]]);
 )";
 
         std::string result = R"(
 (root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
  `-(language::eq_op:AffectationToTupleFromListProcessor<)" +
                              demangled_stdstring + R"( >)
      +-(language::name:t:NameProcessor)
      `-(language::expression_list:ASTNodeExpressionListProcessor)
          +-(language::literal:"foo":ValueProcessor)
-         `-(language::literal:"bar":ValueProcessor)
+         +-(language::literal:"bar":ValueProcessor)
+         +-(language::name:n:NameProcessor)
+         +-(language::integer:1:ValueProcessor)
+         +-(language::real:1.2:ValueProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+         |   `-(language::integer:1:ValueProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+         |   +-(language::integer:1:ValueProcessor)
+         |   `-(language::integer:2:ValueProcessor)
+         +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+         |   +-(language::integer:1:ValueProcessor)
+         |   +-(language::integer:2:ValueProcessor)
+         |   `-(language::integer:3:ValueProcessor)
+         +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+         |   `-(language::row_expression:FakeProcessor)
+         |       `-(language::integer: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::integer:3:ValueProcessor)
+         |       `-(language::integer:4: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("type_id tuples")
+      SECTION("-> (builtin_t)")
       {
         std::string_view data = R"(
 let t : (builtin_t), t= (a,b,a);
@@ -842,48 +949,108 @@ let t : (builtin_t), t= (a,b,a);
       }
     }
 
-    SECTION("tuples from singleton")
+    SECTION("singleton -> tuple")
     {
-      SECTION("B tuples")
+      SECTION(" -> (B)")
       {
-        std::string_view data = R"(
+        SECTION("B -> (B)")
+        {
+          std::string_view data = R"(
 let t : (B), t = true;
 )";
 
-        std::string_view result = R"(
+          std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationToTupleProcessor<bool>)
      +-(language::name:t:NameProcessor)
      `-(language::true_kw:ValueProcessor)
 )";
 
-        CHECK_AST(data, result);
+          CHECK_AST(data, result);
+        }
       }
 
-      SECTION("N tuples")
+      SECTION("-> (N)")
       {
-        std::string_view data = R"(
+        SECTION("B -> (N)")
+        {
+          std::string_view data = R"(
+let t : (N), t = true;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<unsigned long>)
+     +-(language::name:t:NameProcessor)
+     `-(language::true_kw:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("N -> (N)")
+        {
+          std::string_view data = R"(
+let n : N, n = 2;
+let t : (N), t = n;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<unsigned long>)
+     +-(language::name:t:NameProcessor)
+     `-(language::name:n:NameProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("Z -> (N)")
+        {
+          std::string_view data = R"(
 let t : (N), t = 1;
 )";
 
-        std::string_view result = R"(
+          std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationToTupleProcessor<unsigned long>)
      +-(language::name:t:NameProcessor)
      `-(language::integer:1:ValueProcessor)
 )";
 
-        CHECK_AST(data, result);
+          CHECK_AST(data, result);
+        }
       }
 
-      SECTION("Z tuples")
+      SECTION("-> (Z)")
       {
-        std::string_view data = R"(
+        SECTION("B -> (Z)")
+        {
+          std::string_view data = R"(
+let t : (Z), t = true;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<long>)
+     +-(language::name:t:NameProcessor)
+     `-(language::true_kw:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("N -> (Z)")
+        {
+          std::string_view data = R"(
 let n : N, n = 3;
 let t : (Z), t = n;
 )";
 
-        std::string_view result = R"(
+          std::string_view result = R"(
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
  |   +-(language::name:n:NameProcessor)
@@ -893,35 +1060,178 @@ let t : (Z), t = n;
      `-(language::name:n:NameProcessor)
 )";
 
-        CHECK_AST(data, result);
+          CHECK_AST(data, result);
+        }
+
+        SECTION("Z -> (Z)")
+        {
+          std::string_view data = R"(
+let t : (Z), t = -2;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<long>)
+     +-(language::name:t:NameProcessor)
+     `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+         `-(language::integer:2:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
       }
 
-      SECTION("R tuples")
+      SECTION("-> (R)")
       {
-        std::string_view data = R"(
+        SECTION("Z -> (B)")
+        {
+          std::string_view data = R"(
+let t : (R), t = true;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<double>)
+     +-(language::name:t:NameProcessor)
+     `-(language::true_kw:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("N -> (B)")
+        {
+          std::string_view data = R"(
+let n : N, n = 2;
+let t : (R), t = n;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<double>)
+     +-(language::name:t:NameProcessor)
+     `-(language::name:n:NameProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("Z -> (R)")
+        {
+          std::string_view data = R"(
+let t : (R), t = 3;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<double>)
+     +-(language::name:t:NameProcessor)
+     `-(language::integer:3:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R -> (R)")
+        {
+          std::string_view data = R"(
 let t : (R), t = 3.1;
 )";
 
-        std::string_view result = R"(
+          std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationToTupleProcessor<double>)
      +-(language::name:t:NameProcessor)
      `-(language::real:3.1:ValueProcessor)
 )";
 
-        CHECK_AST(data, result);
+          CHECK_AST(data, result);
+        }
       }
 
-      SECTION("R^d tuples")
+      SECTION("-> R^d")
       {
-        std::string_view data = R"(
+        SECTION("B -> (R^1)")
+        {
+          std::string_view data = R"(
+let t : (R^1), t = false;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<TinyVector<1ul, double> >)
+     +-(language::name:t:NameProcessor)
+     `-(language::false_kw:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("N -> (R^1)")
+        {
+          std::string_view data = R"(
+let n : N, n = 3;
+let t : (R^1), t = n;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<TinyVector<1ul, double> >)
+     +-(language::name:t:NameProcessor)
+     `-(language::name:n:NameProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("Z -> (R^1)")
+        {
+          std::string_view data = R"(
+let t : (R^1), t = 3;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<TinyVector<1ul, double> >)
+     +-(language::name:t:NameProcessor)
+     `-(language::integer:3:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R -> (R^1)")
+        {
+          std::string_view data = R"(
+let t : (R^1), t = 3.3;
+)";
+
+          std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<TinyVector<1ul, double> >)
+     +-(language::name:t:NameProcessor)
+     `-(language::real:3.3:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R^d -> (R^d)")
+        {
+          std::string_view data = R"(
 let a : R^2, a = [2,3.1];
 let t1 : (R^2), t1 = a;
 let t2 : (R^3), t2 = 0;
 let t3 : (R^1), t3 = 2.3;
 )";
 
-        std::string_view result = R"(
+          std::string_view result = R"(
 (root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
  |   +-(language::name:a:NameProcessor)
@@ -939,27 +1249,236 @@ let t3 : (R^1), t3 = 2.3;
      `-(language::real:2.3:ValueProcessor)
 )";
 
-        CHECK_AST(data, result);
+          CHECK_AST(data, result);
+        }
       }
 
-      SECTION("string tuples")
+      SECTION("-> (string)")
       {
-        std::string_view data = R"(
+        SECTION("B -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = true;
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::true_kw:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("N -> (string)")
+        {
+          std::string_view data = R"(
+let n : N, n = 2;
+let t : (string), t = true;
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ |   +-(language::name:n:NameProcessor)
+ |   `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::true_kw:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("Z -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = -2;
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+         `-(language::integer:2:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = 3.2;
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::real:3.2:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R^1 -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = [1.5];
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+         `-(language::real:1.5:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R^2 -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = [1.5, 2];
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+         +-(language::real:1.5:ValueProcessor)
+         `-(language::integer:2:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R^3 -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = [1.5, 2, 1];
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+         +-(language::real:1.5:ValueProcessor)
+         +-(language::integer:2:ValueProcessor)
+         `-(language::integer:1:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R^1x1 -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = [[1.5]];
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+         `-(language::row_expression:FakeProcessor)
+             `-(language::real:1.5:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R^2x2 -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = [[1.5, 1],[-2, 3]];
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+         +-(language::row_expression:FakeProcessor)
+         |   +-(language::real:1.5:ValueProcessor)
+         |   `-(language::integer:1:ValueProcessor)
+         `-(language::row_expression:FakeProcessor)
+             +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+             |   `-(language::integer:2:ValueProcessor)
+             `-(language::integer:3:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("R^3x3 -> (string)")
+        {
+          std::string_view data = R"(
+let t : (string), t = [[1.5, 1, -1],[-2, 3, 1],[-5, 1, 6]];
+)";
+
+          std::string result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:AffectationToTupleProcessor<)" +
+                               demangled_stdstring + R"( >)
+     +-(language::name:t:NameProcessor)
+     `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+         +-(language::row_expression:FakeProcessor)
+         |   +-(language::real:1.5:ValueProcessor)
+         |   +-(language::integer:1:ValueProcessor)
+         |   `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+         |       `-(language::integer:1:ValueProcessor)
+         +-(language::row_expression:FakeProcessor)
+         |   +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+         |   |   `-(language::integer:2:ValueProcessor)
+         |   +-(language::integer:3:ValueProcessor)
+         |   `-(language::integer:1:ValueProcessor)
+         `-(language::row_expression:FakeProcessor)
+             +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+             |   `-(language::integer:5:ValueProcessor)
+             +-(language::integer:1:ValueProcessor)
+             `-(language::integer:6:ValueProcessor)
+)";
+
+          CHECK_AST(data, result);
+        }
+
+        SECTION("string -> (string)")
+        {
+          std::string_view data = R"(
 let t : (string), t = "foo";
 )";
 
-        std::string result = R"(
+          std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationToTupleProcessor<)" +
-                             demangled_stdstring + R"( >)
+                               demangled_stdstring + R"( >)
      +-(language::name:t:NameProcessor)
      `-(language::literal:"foo":ValueProcessor)
 )";
 
-        CHECK_AST(data, result);
+          CHECK_AST(data, result);
+        }
       }
 
-      SECTION("type_id tuples")
+      SECTION("-> (type_id)")
       {
         std::string_view data = R"(
 let t : (builtin_t), t = a;