diff --git a/src/language/ASTNodeListAffectationExpressionBuilder.cpp b/src/language/ASTNodeListAffectationExpressionBuilder.cpp
index da34733675dacfaefd6a5e04c416d9f4466d3228..7db25c42bb2a25971cbd99d29dd14508f833cd57 100644
--- a/src/language/ASTNodeListAffectationExpressionBuilder.cpp
+++ b/src/language/ASTNodeListAffectationExpressionBuilder.cpp
@@ -5,7 +5,7 @@
 
 template <typename OperatorT>
 void
-ASTNodeListAffectationExpressionBuilder::_buildListAffectationProcessor(ASTNode& node)
+ASTNodeListAffectationExpressionBuilder::_buildListAffectationProcessorFromExpressionList(ASTNode& node)
 {
   using ListAffectationProcessorT = ListAffectationProcessor<OperatorT>;
 
@@ -122,21 +122,37 @@ ASTNodeListAffectationExpressionBuilder::_buildListAffectationProcessor(ASTNode&
   node.m_node_processor = std::move(list_affectation_processor);
 }
 
-ASTNodeListAffectationExpressionBuilder::ASTNodeListAffectationExpressionBuilder(ASTNode& n)
+template <typename OperatorT>
+void
+ASTNodeListAffectationExpressionBuilder::_buildListAffectationProcessor(ASTNode& node)
+{
+  Assert(node.children[1]->is_type<language::expression_list>() or
+         node.children[1]->is_type<language::function_evaluation>());
+
+  if (node.children[1]->is_type<language::expression_list>()) {
+    this->_buildListAffectationProcessorFromExpressionList<OperatorT>(node);
+  } else {
+    throw parse_error("list expression affectation from function is NIY", std::vector{node.begin()});
+    //    this->_buildListAffectationProcessorFromFunction<OperatorT>(node);
+  }
+}
+
+ASTNodeListAffectationExpressionBuilder::ASTNodeListAffectationExpressionBuilder(ASTNode& node)
 {
-  if (n.children[1]->is_type<language::expression_list>()) {
-    if (n.is_type<language::eq_op>()) {
-      this->_buildListAffectationProcessor<language::eq_op>(n);
-    } else if (n.is_type<language::pluseq_op>()) {
-      this->_buildListAffectationProcessor<language::pluseq_op>(n);
-    } else if (n.is_type<language::minuseq_op>()) {
-      this->_buildListAffectationProcessor<language::minuseq_op>(n);
+  if (node.children[1]->is_type<language::expression_list>() or
+      node.children[1]->is_type<language::function_evaluation>()) {
+    if (node.is_type<language::eq_op>()) {
+      this->_buildListAffectationProcessor<language::eq_op>(node);
+    } else if (node.is_type<language::pluseq_op>()) {
+      this->_buildListAffectationProcessor<language::pluseq_op>(node);
+    } else if (node.is_type<language::minuseq_op>()) {
+      this->_buildListAffectationProcessor<language::minuseq_op>(node);
 
     } else {
-      throw parse_error("undefined affectation operator for tuples", std::vector{n.begin()});
+      throw parse_error("undefined affectation operator for tuples", std::vector{node.begin()});
     }
   } else {
     throw parse_error("unexpected error: invalid right hand side in tuple affectation",
-                      std::vector{n.children[1]->begin()});
+                      std::vector{node.children[1]->begin()});
   }
 }
diff --git a/src/language/ASTNodeListAffectationExpressionBuilder.hpp b/src/language/ASTNodeListAffectationExpressionBuilder.hpp
index d195b141c1beab7658e1c2aa2fa699cbf87178cc..5546a841b41f960476ce89ef6392af82959cba28 100644
--- a/src/language/ASTNodeListAffectationExpressionBuilder.hpp
+++ b/src/language/ASTNodeListAffectationExpressionBuilder.hpp
@@ -6,6 +6,12 @@
 class ASTNodeListAffectationExpressionBuilder
 {
  private:
+  template <typename OperatorT>
+  void _buildListAffectationProcessorFromExpressionList(ASTNode& node);
+
+  template <typename OperatorT>
+  void _buildListAffectationProcessorFromFunction(ASTNode& node);
+
   template <typename OperatorT>
   void _buildListAffectationProcessor(ASTNode& node);