Início / coding / Perguntas / 79202756
Accepted
David
Asked: 2024-11-19 17:04:23 +0800 CST

Por que não há operações monádicas em std::expected<void, Error>

  • 772

Modelei uma função que retorna uma instância de um std::expected<void, Error>- eu disse a mim mesmo "Posso usar um novo padrão, então projetarei minha biblioteca de acordo" - e estava muito positivo para ter um tratamento de erro agradável e concreto. Agora acontece que todas as operações monádicas no std::expectedfuncionam apenas em itens não nulos. Embora haja uma especialização para void, as operações monádicas não estão disponíveis. Entendo que or_elseprecisa retornar o valor - mas há uma especialização para void, então por que isso não deveria funcionar ?

std::expected<void, Error> fun (int);

fun (19).and_then ([]() { doSomething(); }).or_else ([] (Error e) { std::println ("Uh oh error.."); });

Isso produz:

/usr/include/c++/14.2.1/expected:1586:37: error: static assertion failed
 1586 |           static_assert(__expected::__is_expected<_Up>);
      |                         ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~
/usr/include/c++/14.2.1/expected:1586:37: note: ‘std::__expected::__is_expected<void>’ evaluates to false
/usr/include/c++/14.2.1/expected:1587:25: error: ‘std::remove_cvref<void>::type’ {aka ‘void’} is not a class, struct, or union type
 1587 |           static_assert(is_same_v<typename _Up::error_type, _Er>);
      |                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14.2.1/expected:1592:20: error: expression list treated as compound expression in functional cast [-fpermissive]
 1592 |             return _Up(unexpect, std::move(_M_unex));
      |                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/david/tests/cpp/src/expect.cpp: In function ‘int main()’:
/home/david/tests/cpp/src/expect.cpp:49:26: error: invalid use of ‘void’

Qual é o problema aqui? Esse recurso está apenas pela metade (então o padrão está incompleto) ou estou entendendo mal seu ponto?

c++

2 respostas

  1. Best Answer

    O problema é que o callable para and_thene or_elseprecisa retornar uma especialização de std::expectedpara que o encadeamento funcione. Seus lambdas não.

    Se funretornar um inesperado (um erro), and_thennão chamará seu callable, mas precisará encaminhar o erro para o mesmo tipo de unexpectedtipo que o lambda retorna. Então o lambda para and_thendeve retornar std::unexpected<..., Error>. Você pode escolher qualquer tipo "esperado" que você quer que o lambda retorne, contanto que seja o mesmo Errortipo. Você pode ficar com ele void, é claro.

    fun (19).and_then ([]() { doSomething(); return std::expected<void, Error>(); })

    Por outro lado, o callbale to or_elsepode escolher um tipo de erro diferente, mas precisa preservar o tipo esperado em sua std::expectedespecialização retornada. Mas, no geral, o mesmo tratamento deve funcionar.

    fun (19).and_then ([]() { 
          doSomething();
          return std::expected<void, Error>();
}).or_else ([] (Error e) { 
          std::println ("Uh oh error..");
          return std::expected<void, Error>();
});

    Note que optei por or_elseengolir o erro e retornar um std::expectedcom um valor. Você pode escolher encaminhar o erro, é claro.

    ...
.or_else ([] (Error e) { 
          std::println ("Uh oh error..");
          return std::expected<void, Error>(std::unexpect, e);
});
    • 12

  2. Embora isso já tenha sido respondido acima, deixe-me acrescentar que transformprovavelmente transform_erroré o que você esperava para a função de biblioteca.

    fun(19).transform([]() { doSomething(); }).transform_error([](Error e) {
    std::println("Uh oh error..");
    return e;
});

    Há uma diferença entre mônada e functor.

    • and_thene or_elsese comporta monadicamente. and_thenassumir uma função T -> std::expected<U, E>e transformar de std::expected<T, E>parastd::expected<U, E>
    • transforme transform_errorse comporta como functor. transformrecebe uma função T -> Ue transforma de std::expected<T, E>para std::expected<U, E>.

    É interessante que o transform_errorcannot have U = voidif Tnão é void com base em meus testes. A variante monádica é mais expressiva, pois você pode retornar um resultado diferente, por exemplo, retornando a variante unexpected sempre que algo der errado dentro and_then.

    • 9

relate perguntas