bers's questions

Quero me especializar std::formatterdentro do meu namespace. No entanto, isso não funciona como eu gostaria (variante 1). Funciona fora do namespace (variante 3), bem como com uma solução alternativa dentro do namespace (variante 2).

#include <format>
#include <iostream>
#include <string>
#include <type_traits>

class Class {};

#define VARIANT 1

namespace Namespace {

#if VARIANT == 1
template <>
struct std::formatter<Class> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

#if VARIANT == 2
template <typename T>
    requires std::same_as<T, Class>
struct std::formatter<T> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

}  // namespace Namespace

#if VARIANT == 3
template <>
struct std::formatter<Class> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

int main() { std::cout << std::format("{}", Class()) << std::endl; }

Isto está no x64 msvc v19.40 VS17.10. gcc compila apenas a variante 3.

Então, minhas perguntas são: quais são as formas portáteis e em conformidade com os padrões de especialização std::formatterdentro de namespaces (ou em geral)?

Neste exemplo, a última linha falha na compilação. Entendo o porquê, mas me pergunto como posso fazer o compilador entender que quero chamar Class(const int &)para criar uma instância sem nome, em vez de tentar chamar o construtor padrão indefinido e criar uma instância chamada i:

struct Class {
    Class(const int &) {}
};

void foo() {
    int i;

    // Works
    Class(int(i));

    // Fails
    Class(i);
}

Erro no MSVC:

C2371   'i': redefinition; different basic types
E0291   no default constructor exists for class "Class"

O seguinte não é compilado:

#include <memory>
#include <tuple>
#include <utility>

int main()
{
    std::apply(std::make_unique<int>, std::make_tuple(1));
    
    return 0;
}

Mensagem de erro:

In file included from /usr/include/c++/11/bits/unique_ptr.h:37,
                 from /usr/include/c++/11/memory:76,
                 from main.cpp:1:
/usr/include/c++/11/tuple: In instantiation of ‘constexpr decltype(auto) std::__apply_impl(_Fn&&, _Tuple&&, std::index_sequence<_Idx ...>) [with _Fn = std::unique_ptr<int, std::default_delete<int> > (&)(); _Tuple = std::tuple<int>; long unsigned int ..._Idx = {0}; std::index_sequence<_Idx ...> = std::integer_sequence<long unsigned int, 0>]’:
/usr/include/c++/11/tuple:1869:31:   required from ‘constexpr decltype(auto) std::apply(_Fn&&, _Tuple&&) [with _Fn = std::unique_ptr<int, std::default_delete<int> > (&)(); _Tuple = std::tuple<int>]’
main.cpp:7:15:   required from here
/usr/include/c++/11/tuple:1858:27: error: no matching function for call to ‘__invoke(std::unique_ptr > (&)(), std::__tuple_element_t<0, std::tuple >)’
 1858 |       return std::__invoke(std::forward<_Fn>(__f),
      |              ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
 1859 |                            std::get<_Idx>(std::forward<_Tuple>(__t))...);
      |                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/11/tuple:41,
                 from /usr/include/c++/11/bits/unique_ptr.h:37,
                 from /usr/include/c++/11/memory:76,
                 from main.cpp:1:
/usr/include/c++/11/bits/invoke.h:90:5: note: candidate: ‘template constexpr typename std::__invoke_result<_Functor, _ArgTypes>::type std::__invoke(_Callable&&, _Args&& ...)’
   90 |     __invoke(_Callable&& __fn, _Args&&... __args)
      |     ^~~~~~~~
/usr/include/c++/11/bits/invoke.h:90:5: note:   template argument deduction/substitution failed:
/usr/include/c++/11/bits/invoke.h: In substitution of ‘template<class _Callable, class ... _Args> constexpr typename std::__invoke_result<_Functor, _ArgTypes>::type std::__invoke(_Callable&&, _Args&& ...) [with _Callable = std::unique_ptr<int, std::default_delete<int> > (&)(); _Args = {int}]’:
/usr/include/c++/11/tuple:1858:27:   required from ‘constexpr decltype(auto) std::__apply_impl(_Fn&&, _Tuple&&, std::index_sequence<_Idx ...>) [with _Fn = std::unique_ptr<int, std::default_delete<int> > (&)(); _Tuple = std::tuple<int>; long unsigned int ..._Idx = {0}; std::index_sequence<_Idx ...> = std::integer_sequence<long unsigned int, 0>]’
/usr/include/c++/11/tuple:1869:31:   required from ‘constexpr decltype(auto) std::apply(_Fn&&, _Tuple&&) [with _Fn = std::unique_ptr<int, std::default_delete<int> > (&)(); _Tuple = std::tuple<int>]’
main.cpp:7:15:   required from here
/usr/include/c++/11/bits/invoke.h:90:5: error: no type named ‘type’ in ‘struct std::__invoke_result > (&)(), int>’

Como isso pode ser consertado?

O código a seguir funciona em numpy 1.26.4, mas não em numpy 2.0.0rc1, fornecendo

OverflowError: inteiro Python -256 fora dos limites para int8

import numpy as np
np.array([1], dtype=np.int8) + (-256)

Isso é esperado? É devido à adoção da NEP 50 ? Em caso afirmativo, que parte da NEP 50 determina este novo comportamento?