shynur's questions

Eu tentei std::enable_ife requires:

template <typename Ret>
struct promise_type {
  auto get_return_object() {/*...*/}
  auto initial_suspend() {/*...*/}

  auto return_void()
    -> std::enable_if_t<std::is_void_v<Ret>> {/*...*/}
  auto return_value(Ret)
    -> std::enable_if_t<!std::is_void_v<Ret>> {/*...*/}

  void unhandled_exception() {/*...*/}
  auto final_suspend() noexcept {/*...*/}

  // Rest of promise_type's definition ...
};

In file included from src/TestSyncTask.cpp:1:
In file included from include/asyncxx/SyncTask.hpp:2:
In file included from /usr/local/lib/gcc/x86_64-pc-linux-gnu/15.0.1/../../../../include/c++/15.0.1/coroutine:48:
/usr/local/lib/gcc/x86_64-pc-linux-gnu/15.0.1/../../../../include/c++/15.0.1/type_traits:2837:44: error: no type named 'type' in 'std::enable_if<false>'; 'enable_if' cannot be used to disable this declaration
 2837 |     using enable_if_t = typename enable_if<_Cond, _Tp>::type;
      |                                            ^~~~~
include/asyncxx/SyncTask.hpp:12:36: note: in instantiation of template type alias 'enable_if_t' requested here
   12 |         auto return_void() -> std::enable_if_t<std::is_void_v<Ret>> {}
      |                                    ^
src/TestSyncTask.cpp:4:15: note: in instantiation of member class 'SyncTask<int>::promise_type' requested here
    4 | SyncTask<int> async_main(const int argc, const char *const argv[]) {
      |               ^
1 error generated.

template <typename Ret>
struct promise_type {
  auto get_return_object() {/*...*/}
  auto initial_suspend() {/*...*/}

  auto return_void() requires std::is_void_v<Ret> {/*...*/}
  auto return_value(Ret) requires (!std::is_void_v<Ret>) {/*...*/}

  void unhandled_exception() {/*...*/}
  auto final_suspend() noexcept {/*...*/}

  // Rest of promise_type's definition ...
};

src/TestSyncTask.cpp:4:15: error: the coroutine promise type 'promise_type' declares both 'return_value' and 'return_void'
    4 | SyncTask<int> async_main(const int argc, const char *const argv[]) {
      |               ^
include/asyncxx/SyncTask.hpp:12:14: note: member 'return_void' first declared here
   12 |         auto return_void() requires std::is_void_v<Ret> {}
      |              ^
include/asyncxx/SyncTask.hpp:13:14: note: member 'return_value' first declared here
   13 |         auto return_value(Ret val) requires (!std::is_void_v<Ret>) {
      |              ^
1 error generated.

Como posso consertar isso?

No GCC 15, std::noop_coroutinea definição de é

{ return std::noop_coroutine_handle(); }

std::noop_coroutine_handleé definido por:

using noop_coroutine_handle = std::coroutine_handle<std::noop_coroutine_promise>;

Para obter uma corrotina sem operação, escrevemos

std::noop_coroutine()

que (eu acho) é equivalente a

std::noop_coroutine_handle{}

e

std::coroutine_handle<std::noop_coroutine_promise>{}

Então acredito que a biblioteca padrão só precisa fornecer std::noop_coroutine_promise(junto com certas especializações que a utilizam como um parâmetro de modelo).

Por que o padrão introduziu três novos símbolos? (Parece um pouco arbitrário — apenas minha opinião pessoal.)

Uma função constexpr pode ser chamada durante o tempo de execução ou no tempo de compilação se seus argumentos forem constexpr .

Espero implementar algo como:

constexpr auto f() {
    /* some code ... */

    if constexpr ("called in compilation time") {
        // ...
    } else {
        // ...
    }

    /* rest code ... */
}

Como faço isso?

Eu sei que isso (void)0é um no-op em C/C++. No entanto, quando eu estava olhando o código em <cassert>, eu vi void (0).

Acho que é algo como int (0)ou int{0}. Eu também tentei void{}e funciona. Parece que esta é uma inicialização zero para void.

Mas voidé um tipo incompleto , como é que o compilador não reclama? ( g++-14 -std=c++23 -Wall)

Eu tentei no PostgreSQL, AlaSQL e alguns outros RDBMSs:

SELECT 1 AS one,  1  * 2 AS two;  -- works
SELECT 1 AS one, one * 2 AS two;  -- doesn't

Parece que eles não apoiam isso.

EDITAR:

Como @juergen d mencionou no comentário:

Você pode fazer isso no MySQL: https://stackoverflow.com/a/18020948/575376

O exemplo acima mostra a diferença entre os diferentes RDBMSs. É por isso que faço esta pergunta.

Se o ISO SQL não garantir tal comportamento, eu tentaria evitá-lo. Infelizmente, parece que algumas pessoas acham que esta é uma pergunta inútil (provavelmente é, mas é importante para mim porque QUERO ESCREVER O CÓDIGO MAIS PROTÁVEL POSSÍVEL ).

Então eu me pergunto se é um comportamento ISO SQL .
Agradeceríamos se fossem fornecidos links para materiais de referência específicos.

Não estou pedindo documentação que descreva funcionalidades que não existem. Caso alguém queira criticar, talvez eu deva reformular a pergunta: O ISO SQL especifica se SELECTé executado como um todo ou pode ser executado em partes?