Auto does not work with stuctured binding

I'm trying to understand how structured bindings for custom types work in practice. The following code does not compile with an error:

error: cannot bind non-const lvalue reference of type ‘Customer&’ to an rvalue of type ‘Customer

I'm probably missing some fundamental understanding. If I either replace auto with auto& or Customer& to with const Customer& everything compiles fine. Why rvalue of Customer is mentioned in the error message?

#include <iostream>
#include <tuple>

struct Customer
{
    int id = 10;
};

template<>
struct std::tuple_size<Customer> : std::integral_constant<std::size_t, 1> {};

template<>
struct std::tuple_element<0, Customer>
{
    using type = int;
};

template<std::size_t id>
auto get(Customer& customer)
{
    if constexpr (id == 0)
    {
        return customer.id;
    }
}

int main() {
    Customer customer;
    auto [id] = customer; // Ouch, error
    std::cout << id;
}

The object passed to get is defined to be an xvalue in your case, it's not customer directly.

From cppreference:

> A structured binding declaration first introduces a uniquely-named variable (here denoted by e) to hold the value of the initializer, as follows:
>
> [Array case]
>
> Otherwise e is defined as if by using its name instead of [ identifier-list ] in the declaration.
> We use E to denote the type of the expression e.

> For each identifier, a variable whose type is "reference to std::tuple_element<i, E>::type" is introduced: lvalue reference if its corresponding initializer is an lvalue, rvalue reference otherwise. The initializer for the i-th variable is
>
> - e.get<i>(), if lookup for the identifier get in the scope of E by class member access lookup finds at least one declaration that is a function template whose first template parameter is a non-type parameter
> - Otherwise, get<i>(e), where get is looked up by argument-dependent lookup only, ignoring non-ADL lookup.
> In these initializer expressions, e is an lvalue if the type of the entity e is an lvalue reference (this only happens if the ref-qualifier is & or if it is && and the initializer expression is an lvalue) and an xvalue otherwise (this effectively performs a kind of perfect forwarding), i is a std::size_t prvalue, and <i> is always interpreted as a template parameter list.

TLDR; Basically, get is called on a copy of customer(that has the value category of xvalue) and not on lvalue customer itself.

When you use auto [id] = customer;, it captures customer in a hidden variable(aka dummy variable) say e. Then the call to getis made on e which is a copy and has the value category of rvalue(xvalue to be specific in this case) and since an rvalue of type T cannot be bound to a non-const lvalue reference to T, we get the mentioned error.