Como retornar um range::view em um std::expected?

Até onde posso ver, não há uma boa solução para esse problema.

O melhor que posso fazer é usar autoo tipo de retorno. Para isso, você precisa alterar a função para retornar o mesmo tipo em todos os caminhos. Você faz isso obtendo o tipo da visualização com decltypee explicitamente usa o std::expectedtipo no retorno. Para o valor inesperado, eu uso a std::expectedsobrecarga do construtor com a std::unexpected_ttag .

auto get_range()
{
    auto r = data | std::ranges::views::take(x);

    if (some_condition(x))
        return std::expected<decltype(r), error>{std::unexpect, error{}};
    

    return std::expected<decltype(r), error>{r};
}

Isso colocará o tipo de visualização de intervalo no protótipo da função. Isso significa que modificar a implementação em como você constrói rou alterar o datatipo alterará o protótipo da função. (porque cada visualização tem um tipo distinto). Isso pode ser um problema ou não, dependendo do seu caso de uso da função.

As visualizações são preguiçosas, então construir rantes de verificar sua condição não deve ser um problema. No entanto, se for ou se você quiser evitar isso, você pode obter o tipo de rcom std::declval, mas é trabalhoso e quebradiço.

Ao retornar a std::expected<DifficultTypeToSpell, E>de uma função, pode-se evitar soletrar o tipo completamente, usando a interface monádica de std::expected. Comece com a std::expected<T, E>que contém o erro real, ou alguma construção padrão T(que poderia até ser void), e transformcom a expressão que realmente fornece o tipo que é difícil de soletrar.

Então o código poderia ser algo como isto:

auto get_range()
{
    return [] -> std::expected<void, error> {   // start with a simple type
        if (some_condition(x)) 
            return std::unexpected(error{});
        return {};
    }().transform([] {    // and then transform to the desired type
            return data | std::ranges::views::take(x);
    });
}

O tipo de intervalo é complicado, o mais curto que você pode fazer é inferir o tipo a partir do uso usando decltype e declval .

por exemplo

#include <ranges>
#include <vector>

int main()
{
   std::vector<int> arr;
   decltype(std::declval<std::vector<int>&>() | std::views::take(5)) r = arr | std::views::take(5);
}

o tipo de ré muito complicado de escrever, além disso, se você tentar retorná-lo da função, o intervalo pode ficar oscilando, e você só pode retornar 1 tipo de intervalo, então não pode aplicar condicionalmente transformações diferentes.

a melhor alternativa é passar um functor como o que std::for_each faz e aplicá-lo ao intervalo, dessa forma você não corre o risco de usar um intervalo pendente, caso contrário, pode ser mais seguro retornar a std::vectore encarar a situação, talvez usar pmr::vectorpara reduzir a sobrecarga de alocações.

Prefiro usar tipos de retorno finais quando o tipo de retorno fica complicado.

Poderia ficar assim e o resto da sua função permaneceria inalterado:

auto get_range() -> std::expected<decltype(data | std::ranges::views::take(x)),
                                  decltype(errorcode)> {
    if (some_condition(x))
        return std::unexpected(errorcode);

    return data | std::ranges::views::take(x);
}