Com o C ++ 17, teremos a possibilidade de retornar tipos imóveis (incluindo não copiáveis), comostd::mutex, via o que pode ser considerado como otimização do valor de retorno garantido (RVO):Elisão de cópia garantida através de categorias de valor simplificadas:

struct nocopy { nocopy(nocopy&) = delete; nocopy() = default; };
auto getRVO(){
    return nocopy();
}

Também teremosligações estruturadas, permitindo:

tuple<T1,T2,T3> f();
auto [x,y,z] = f();

ou (aqui também usando meu entendimento do recursodedução de argumento de modelo para construtores)

template<typename T1,typename T2,typename T3>
struct many {
  T1 a;
  T2 b;
  T3 c;
};
// (Original questions missed 'many' on the next line. Thanks, T.C.)
auto f(){ return many{string(),5.7, false} }; 
auto [x,y,z] = f();

Mas esses recursos se compõem para permitir algo assim?

auto get_ensured_rvo_str(){
    return std::pair(std::string(),nocopy());
}

auto get_class_and_mutex(){
    return many{SomeClass(),std::mutex(),std::string()};
}

int main(){
    auto rvoStr = get_ensured_rvo_str().first;
    auto [ mtx,sc,str ] = get_class_and_mutex();
}

Meu pensamento é que, para que isso funcione, seria necessário RVO garantido dos argumentos agregados do construtor na formaçãostd::tuple oumany, mas isso não seria nomeado RVO (NRVO), que não está especificamente incluído na proposta P0144R2?

Nota lateral: P0144R2 menciona especificamente que tipos somente de movimento são suportados:

2.6 Tipos somente de movimentação

Tipos somente de movimentação são suportados. Por exemplo:

struct S { int i; unique_ptr<widget> w; };
S f() { return {0, make_unique<widget>()}; }
auto [ my_i, my_w ] = f();