Assignment function as alternative to std::tie What do you think about this assignment &quot;idiom&quot;?
template &lt;typename ...A&gt;
constexpr auto assign(A&amp; ...a) noexcept
{
  return [&amp;](auto&amp;&amp; ...v)
//  noexcept(noexcept(((a = std::forward&lt;decltype(v)&gt;(v)), ...)))
    {
      ((a = std::forward&lt;decltype(v)&gt;(v)), ...);
    };
}

It seems a better alternative to me than the std::tie() idiom. Uncommenting the comment could cause a segfault in gcc.
Usage:
int a, b, c;
assign(a, b, c)(1, 2, 3);
This &quot;idiom&quot; seems strictly more confusing than the std::tie(a,b,c) = std::make_tuple(1,2,3) idiom. (I mean, the latter is an idiom because multiple people use it and know it. Your thing doesn't count as an idiom yet because nobody uses or understands it.)
Your thing does save a lot of template instantiations — you don't have to instantiate std::tuple at all, for example. That's potentially nice for people who are doing lots of multiple assignments in header files and care about compile times. But who's doing lots of multiple assignments in header files??
Your thing doesn't fix the most important shortcoming of std::tie, which is that you can't use it to introduce a new variable. It's still fundamentally a std::cin-style API, where the caller is supposed to define all their variables with garbage values and then use this API to mutate them into the desired state.
// To mutate three variables:

int a, b, c;
assign(a, b, c)(1, 2, 3);
std::tie(a, b, c) = std::tuple{1, 2, 3};  // same deal, easier to read, harder to compile

// To define three new variables (ish):

auto [a, b, c] = std::tuple{1, 2, 3};

&quot;C++17 structured binding that also includes an existing variable&quot; gives the skeleton of an API that could be used to define and mutate different sets of variables at the same time:
// To define one new variable and mutate two others:

auto [a] = AndTie(_1, b, c) = std::tuple{1, 2, 3};

But again, I wouldn't describe this as an &quot;idiom&quot;, because if you showed it to an ordinary C++ programmer who knew all the C++ idioms, they likely still wouldn't understand it at a glance.

Oh, and a code-style nit: I would prefer to see your fold-expression with spaces around the , operator, to emphasize that it's an operator and not a separator. Like this:
((a = std::forward&lt;decltype(v)&gt;(v)) , ...);

and in fact as long as we're saving on function template instantiations, let's do
((a = static_cast&lt;decltype(v)&gt;(v)) , ...);

The inner set of parentheses is redundant, I think, but I'm keeping them. (Precisely because I had to say &quot;I think.&quot; I'm not even gonna go find out. They're a good idea.)