customization points that suck less...makes it impossible to include a header containing a...

IntroOld ways

InterludesNew way

C++20 conceptsSummary

Customization Points that Suck Less

Micha l DominiakNokia Networks

[email protected]@Guriwesu

Micha l Dominiak Nokia Networks [email protected] @Guriwesu Customization Points that Suck Less

IntroOld ways

InterludesNew way

What is a customization point?Is the problem even important?

Outline

1. Introduction

2. Existing and well known techniques

3. Interludes

4. Proposed technique

5. Tie-in with C++20 concepts

IntroOld ways

InterludesNew way

What is a customization point?

A customization point is a well-defined way to specify the behavior of a feature for owntypes and such.

IntroOld ways

InterludesNew way

Is the problem even important?

Yes, as proven by the amount of threads about this topic on std-proposals and on thecommittee’s reflectors.

IntroOld ways

InterludesNew way

std::hash, structured bindings: template specializationsstd::swap, structured bindings: ADLCustomization point objects

Outline

1. Introduction

3. Interludes

IntroOld ways

InterludesNew way

std::hash, structured bindings: template specializations

struct foo {

int value;

namespace std {

template<>

struct hash<foo> {

std::size_t operator()(const foo & f) const {

return std::hash(f.value);

IntroOld ways

InterludesNew way

struct foo {

int value;

namespace std {

template<>

struct hash<foo> {

IntroOld ways

InterludesNew way

struct foo {

int value;

template<>

struct std::hash<foo> {

IntroOld ways

InterludesNew way

namespace foo {

struct bar {

int value;

template<>

IntroOld ways

InterludesNew way

namespace foo {

struct bar {

int value;

template<>

IntroOld ways

InterludesNew way

namespace foo {

struct bar {

int value;

template<>

struct ::std::hash<foo> {

IntroOld ways

InterludesNew way

this is tiresome

sometimes there’s a lot of namespaces you’re in

makes it impossible to include a header containing a specialization like that insidea namespace

IntroOld ways

InterludesNew way

this is tiresome

IntroOld ways

InterludesNew way

this is tiresome

IntroOld ways

InterludesNew way

some of the customization points for structured bindings are std::tuple size

and std::tuple element

both are defined in <tuple>

that header is not freestanding

and also you need to escape all your namespaces in this case too

and there’s more of them than just one

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

the problem with specializing types in other namespaces might be resolved in thenear future: P0665

other problems still remain: the standard uses them too extensively; no direct wayto inherit the ”default” behavior for just a part of the functionality

IntroOld ways

InterludesNew way

other problems still remain: the standard uses them too extensively;

no direct wayto inherit the ”default” behavior for just a part of the functionality

IntroOld ways

InterludesNew way

other problems still remain: the standard uses them too extensively; no direct wayto inherit the ”default” behavior for just a part of the functionality

IntroOld ways

InterludesNew way

template<typename T>

struct container_traits {

static std::size_t size(const T & t) {

return t.size();

// plus non-const versions

static auto begin(const T & t) {

return t.begin();

static auto end(const T & t) {

return t.end();

class some_quasi_container {

auto element_count() const;

auto begin() const;

auto end() const;

template<>

struct container_traits<some_quasi_container> {

static std::size_t size(const some_quasi_container & sqc) {

return sqc.element_count();

IntroOld ways

InterludesNew way

return t.size();

return t.begin();

return t.end();

auto begin() const;

auto end() const;

template<>

IntroOld ways

InterludesNew way

return t.size();

return t.begin();

return t.end();

auto begin() const;

auto end() const;

template<>

IntroOld ways

InterludesNew way

struct default_container_traits {

return t.size();

return t.begin();

return t.end();

struct container_traits : default_container_traits<T> {};

template<>

struct container_traits<some_quasi_container> : default_container_traits<some_quasi_container> {

IntroOld ways

InterludesNew way

return t.size();

return t.begin();

return t.end();

template<>

IntroOld ways

InterludesNew way

return t.size();

return t.begin();

return t.end();

template<>

IntroOld ways

InterludesNew way

std::swap, structured bindings: ADL

- argument dependent lookup

arguments to an unqualified function call can pull additional overloads into theoverload set

auto c = a + b;

auto c = operator+(a, b);

IntroOld ways

InterludesNew way

ADL - argument dependent lookup

auto c = a + b;

IntroOld ways

InterludesNew way

auto c = a + b;

IntroOld ways

InterludesNew way

auto c = a + b;

IntroOld ways

InterludesNew way

auto c = a + b;

IntroOld ways

InterludesNew way

void swap(T & a, T & b) noexcept(/* ... */);

template<typename ForwardIt1, typename ForwardIt2>

void iter_swap(ForwardIt1 a, ForwardIt2 b)

using std::swap;

swap(*a, *b);

IntroOld ways

InterludesNew way

using std::swap;

swap(*a, *b);

IntroOld ways

InterludesNew way

using std::swap;

swap(*a, *b);

IntroOld ways

InterludesNew way

SFINAE is hard

IntroOld ways

InterludesNew way

SFINAE is hard

auto iter_swap(ForwardIt1 a, ForwardIt2 b)

-> decltype(swap(*a, *b))

using std::swap;

swap(*a, *b);

IntroOld ways

InterludesNew way

SFINAE is hard

-> decltype(swap(*a, *b))

using std::swap;

swap(*a, *b);

Wrong!

IntroOld ways

InterludesNew way

SFINAE is hard

namespace _detail {

using std::swap;

void _swap(T & a, T & b) {

swap(a, b);

-> decltype(_detail::_swap(*a, *b))

_detail::_swap(*a, *b);

IntroOld ways

InterludesNew way

structured bindings use ADL to select the overload for get, if a member .get isnot found

this differs from normal calls by being only ADL, without normal overloadresolution (this is also the case for the range-based for loop, with begin and end)

IntroOld ways

InterludesNew way

this differs from normal calls by being only ADL, without normal overloadresolution

(this is also the case for the range-based for loop, with begin and end)

IntroOld ways

InterludesNew way

this differs from normal calls by being only ADL, without normal overloadresolution (this is also the case for the range-based for loop, with begin and end)

IntroOld ways

InterludesNew way

class A {

int _member = 17;

char _another = 'c';

public:

const auto & member() const { return _member; }

const auto & another() const { return _another; }

auto [ member, another ] = A{};

template<>

struct std::tuple_size<A> { static const constexpr auto value = 2; };

template<>

struct std::tuple_element<0, A> { using type = const int &; };

template<>

struct std::tuple_element<1, A> { using type = const char &; };

template<std::size_t I>

const auto & get(const A & value);

template<>

const auto & get<0>(const A & value) {

return value.member();

template<>

return value.another();

IntroOld ways

InterludesNew way

class A {

int _member = 17;

public:

template<>

const auto & get(const A & value);

template<>

return value.member();

template<>

return value.another();

IntroOld ways

InterludesNew way

class A {

int _member = 17;

public:

template<>

const auto & get(const A & value) {

if constexpr (I == 0) { return value.member(); }

else if constexpr (I == 1) { return value.another(); }

IntroOld ways

InterludesNew way

class A {

int _member = 17;

public:

template<>

const auto & get(const A & value) {

if constexpr (I == 0) { return value.member(); }

else if constexpr (I == 1) { return value.another(); }

IntroOld ways

InterludesNew way

ADL is not my favorite

my own library with an optional implementation, with make optional

inside the same library - unqualified call to make optional in generic code

worked great until I tried GCC 7.1

it turned out I called it on std::vector

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

Customization point objects

http://wg21.link/n4381

IntroOld ways

InterludesNew way

namespace __detail {

template<class T, size_t N>

constexpr T* begin(T (&a)[N]) noexcept {

return a;

struct __begin_fn {

template<class R>

constexpr auto operator()(R && rng) const ->

decltype(begin(forward<R>(rng))) {

return begin(forward<R>(rng));

IntroOld ways

InterludesNew way

// To avoid ODR violations:

template<class T>

struct __static_const {

static constexpr T value{};

template<class T>

constexpr T __static_const<T>::value;

// std::begin is a global function object!

namespace {

constexpr auto const & begin =

__static_const<__detail::__begin_fn>::value;

IntroOld ways

InterludesNew way

namespace __detail {

template<class T, size_t N>

constexpr T* begin(T (&a)[N]) noexcept {

return a;

struct __begin_fn {

template<class R>

constexpr auto operator()(R && rng) const ->

decltype(begin(forward<R>(rng))) {

return begin(forward<R>(rng));

inline auto begin = __detail::__begin_fn{};

IntroOld ways

InterludesNew way

chosen as the way to do future customization points

already used in the Ranges TS, the Networking TS, and the future Executors TS

helps avoid the ”accidentally didn’t use ADL on this call” problem

solves the ”I need a new namespace to get ADL in decltype to work” problem

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

The Haskell Interlude: TypeclassesThe Rust Interlude: TraitsThe C++0x Interlude: Concept Maps

Outline

1. Introduction

3. Interludes

IntroOld ways

InterludesNew way

The Haskell Interlude: Typeclasses

https://twitter.com/ValaAfshar/status/860924553844969473/photo/1

IntroOld ways

InterludesNew way

one = 1

const x _ = x

const_12 = const 12

const_12 "abc" -- this "returns" 12

IntroOld ways

InterludesNew way

one = 1

const x _ = x

const_12 = const 12

IntroOld ways

InterludesNew way

one = 1

const x _ = x

const_12 = const 12

IntroOld ways

InterludesNew way

one :: Int

one = 1

const :: a -> b -> a

const x _ = x

const_12 :: a -> Int

const_12 = const 12

IntroOld ways

InterludesNew way

one :: Int

one = 1

const x _ = x

const_12 = const 12

IntroOld ways

InterludesNew way

one :: Int

one = 1

const x _ = x

const_12 = const 12

IntroOld ways

InterludesNew way

one :: Num a => a

one = 1

const x _ = x

const_12 :: Num a => b -> a

const_12 = const 12

IntroOld ways

InterludesNew way

one :: Num a => a

one = 1

const x _ = x

const_12 = const 12

IntroOld ways

InterludesNew way

one :: Num a => a

one = 1

const x _ = x

const_12 = const 12

IntroOld ways

InterludesNew way

class Num a where

(+), (-), (*) :: a -> a -> a

negate :: a -> a

abs :: a -> a

fromInteger :: Integer -> a

x - y = x + negate y

negate x = 0 - x

IntroOld ways

InterludesNew way

data Complex a = Complex a a

foo = Complex 1.2 3.4

instance Num a => Num (Complex a) where

Complex x y + Complex u v = Complex (x + u) (y + v)

Complex x y - Complex u v = Complex (x - u) (y - v)

Complex x y * Complex u v = Complex (x * u - y * v) (x * v + y * u)

fromInteger x = Complex (fromInteger x) 0

negate (Complex x y) = Complex (negate x) (negate y)

bar = foo - Complex 1 2

baz = bar + 1

IntroOld ways

InterludesNew way

baz = bar + 1

IntroOld ways

InterludesNew way

baz = bar + 1

IntroOld ways

InterludesNew way

baz = bar + 1

IntroOld ways

InterludesNew way

-- Complex x y - Complex u v = Complex (x - u) (y - v)

baz = bar + 1

IntroOld ways

InterludesNew way

The Rust Interlude: Traits

struct Complex {

real: i32,

comp: i32

trait Add<RHS = Self> {

type Output;

fn add(self, rhs: RHS) -> Self::Output;

impl Add for Complex {

type Output = Complex;

fn add(self, other: Complex) -> Complex {

Complex{ real: self.real + other.real, comp: self.comp + other.comp }

IntroOld ways

InterludesNew way

struct Complex {

real: i32,

comp: i32

type Output;

IntroOld ways

InterludesNew way

struct Complex {

real: i32,

comp: i32

type Output;

}Micha l Dominiak Nokia Networks [email protected] @Guriwesu Customization Points that Suck Less

IntroOld ways

InterludesNew way

The C++0x Interlude: Concept Maps

auto concept LessThanComparable<typename T> {

bool operator<(T, T);

requires LessThanComparable<T>

const T & min(const T & x, const T & y) {

return (y < x) ? y : x;

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

auto concept Numeric<typename T> {

T operator+(const T &, const T &);

T operator-(const T &, const T &);

T operator*(const T &, const T &);

T negate(const T &);

T abs(const T &);

IntroOld ways

InterludesNew way

struct complex {

T real, comp;

concept_map Numeric<complex<T>> {

complex<T> operator+(const complex<T> & lhs, const complex<T> & rhs) {

return { lhs.real + rhs.real, lhs.comp + rhs.comp };

// ...

IntroOld ways

InterludesNew way

struct complex {

T real, comp;

concept_map Numeric<complex<T>> {

complex<T> operator+(const complex<T> & lhs, const complex<T> & rhs) {

return { lhs.real + rhs.real, lhs.comp + rhs.comp };

// ...

IntroOld ways

InterludesNew way

Basic ideaDefault instancesEnter templates: everything is terribleType erasure

Outline

1. Introduction

3. Interludes

IntroOld ways

InterludesNew way

Basic idea

We can specialize a member of the current namespace without leaving it.

The class template that the library facility will look into is not in the currentnamespace.

A type we are defining is in the current namespace.

IntroOld ways

InterludesNew way

Basic idea

IntroOld ways

InterludesNew way

Basic idea

IntroOld ways

InterludesNew way

Basic idea

namespace foo {

struct tuple_size_tc {}; // tag for the typeclass

struct tuple_size {

static constexpr const std::size_t value = T::template instance<tuple_size_tc>::value;

namespace bar {

struct baz {

struct instance; // this *is* in the current namespace; can specialize!

template<>

struct baz::instance<foo::tuple_size_tc> {

static constexpr const std::size_t value = 17;

IntroOld ways

InterludesNew way

Basic idea

namespace bar {

INSTANCE(foo::tuple_size_tc, baz) {

IntroOld ways

InterludesNew way

Default instances

struct tuple_size_tc {

template<typename Typeclass, typename T>

struct instance;

struct tuple_size {

static constexpr const std::size_t value

= T::template instance<tuple_size_tc, T>::value;

struct tuple_size_tc::instance<tuple_size_tc, T> {

struct baz : tuple_size_tc {};

IntroOld ways

InterludesNew way

Default instances

// otherwise, use the one from the typeclass tag

template<typename Typeclass, typename T, typename = void>

struct typeclass_trait {

using type = typename Typeclass::template instance<Typeclass, T>;

// if there's a member template `instance` in T, use that

struct typeclass_trait<Typeclass, T,

void_t<typename T::template instance<Typeclass, T>>> {

using type = typename T::template instance<Typeclass, T>;

using tc_instance = typename typeclass_trait<Typeclass, T>::type;

IntroOld ways

InterludesNew way

Default instances

struct instance;

struct tuple_size {

static constexpr const std::size_t value = tc_instance<tuple_size_tc, T>::value;

struct tuple_size_tc::instance<tuple_size_tc, std::vector<T>> {

IntroOld ways

InterludesNew way

Default instances

struct instance;

struct tuple_size {

static constexpr const std::size_t value = tc_instance<tuple_size_tc, T>::value;

struct tuple_size_tc::instance<tuple_size_tc, std::vector<T>> {

IntroOld ways

InterludesNew way

Default instances

DEFAULT_INSTANCE(tuple_size_tc, T) {

IntroOld ways

InterludesNew way

Default instances

struct swappable

TYPECLASS_INSTANCE(typename T);

auto swap(T & lhs, T & rhs) -> decltype(tc_instance<swappable, T>::swap(lhs, rhs))

noexcept(noexcept(tc_instance<swappable, T>::swap(lhs, rhs)))

tc_instance<swappable, T>::swap(lhs, rhs);

IntroOld ways

InterludesNew way

Default instances

struct swappable

auto swap(T & lhs, T & rhs) -> decltype(tc_instance<swappable, T>::swap(lhs, rhs))

noexcept(noexcept(tc_instance<swappable, T>::swap(lhs, rhs)))

tc_instance<swappable, T>::swap(lhs, rhs);

IntroOld ways

InterludesNew way

Default instances

struct swappable

auto swap(T & lhs, T & rhs) SFINAE_FUNCTION(

tc_instance<swappable, T>::swap(lhs, rhs)

IntroOld ways

InterludesNew way

Default instances

struct swappable

auto swap(T & lhs, T & rhs) => tc_instance<swappable, T>::swap(lhs, rhs);

IntroOld ways

InterludesNew way

Default instances

struct swappable

auto swap(T & lhs, T & rhs) SFINAE_FUNCTION(

tc_instance<swappable, T>::swap(lhs, rhs)

IntroOld ways

InterludesNew way

Default instances

DEFAULT_INSTANCE(swappable, T)

// simplified *a lot* for the purpose of the talk

static void swap(T & lhs, T & rhs)

auto tmp = std::move(lhs);

lhs = std::move(rhs);

rhs = std::move(tmp);

IntroOld ways

InterludesNew way

Default instances

class A {

int _member = 17;

public:

template<typename TC, typename T>

struct instance; // do this once!

INSTANCE(TupleLike, A)

using types = reference_tuple<const int, const char>;

auto to_tuple(const A & a) { return types{ a.member(), a.another() }; }

IntroOld ways

InterludesNew way

Default instances

class A {

int _member = 17;

public:

template<typename TC, typename T>

struct instance; // do this once!

INSTANCE(TupleLike, A)

IntroOld ways

InterludesNew way

Default instances

class A {

int _member = 17;

public:

};// with P0665

template<>

struct ::std::tuple_like<A> {

a need for the macros goes away in some cases if the paper gets acceptedthis doesn’t however solve the problem of inheriting the default implementationsof a part of the interface

IntroOld ways

InterludesNew way

Default instances

class A {

int _member = 17;

public:

};// with P0665

template<>

a need for the macros goes away in some cases if the paper gets accepted

this doesn’t however solve the problem of inheriting the default implementationsof a part of the interface

IntroOld ways

InterludesNew way

Default instances

class A {

int _member = 17;

public:

};// with P0665

template<>

a need for the macros goes away in some cases if the paper gets acceptedthis doesn’t however solve the problem of inheriting the default implementationsof a part of the interface

IntroOld ways

InterludesNew way

Enter templates: everything is terrible

struct counter_definition {

void set_value(T);

T get_value() const;

T increment();

IntroOld ways

InterludesNew way

struct counter {

struct instance;

template<typename Counter>

static void set_value(Counter c, T t) SFINAE_FUNCTION(

tc_instance<counter_tc, T>::set_value(c, t);

IntroOld ways

InterludesNew way

DEFAULT_INSTANCE(counter<T>, U)

static void set_value(U & u, T val) { u.set_value(std::move(val)); }

static T get_value(const U & u) { return u.get_value(); }

static T increment(U & u) { return ++u; }

IntroOld ways

InterludesNew way

struct atomic_counter

TYPECLASS_INSTANCE(typename U);

void set_value(T val) { _value = std::move(val); }

T get_value() const { return _value; }

T add(T v) { return _value += std::move(v); }

private:

std::atomic<T> _value;

IntroOld ways

InterludesNew way

INSTANCE(counter<T>, atomic_counter<T>)

static T increment(atomic_counter<T> & c) { return c.add(1); }

error: cannot specialize (with ’template⟨⟩’) a member of an unspecialized template

IntroOld ways

InterludesNew way

INSTANCE(counter<T>, atomic_counter<T>)

error: cannot specialize (with ’template⟨⟩’) a member of an unspecialized template

IntroOld ways

InterludesNew way

struct counter {

template<typename Typeclass, typename U>

struct instance;

struct atomic_counter {

template<typename Typeclass, typename U>

struct instance;

template<typename T> template<>

struct atomic_counter<T>::instance<counter<T>, atomic_counter<T>>

: counter<T>::template instance<counter<T>, atomic_counter<T>> {};

IntroOld ways

InterludesNew way

INSTANCE_TEMPLATE_HELPER;

struct atomic_counter

TYPECLASS_INSTANCE_TEMPLATE((typename U), (atomic_counter), counter);

void set_value(T val) { _value = std::move(val); }

T get_value() const { return _value; }

T add(T v) { return _value += std::move(v); }

private:

std::atomic<T> _value;

IntroOld ways

InterludesNew way

INSTANCE_TEMPLATE((typename T), (atomic_counter), counter,

atomic_counter<T>)

IntroOld ways

InterludesNew way

#define INSTANCE_TEMPLATE_HELPER \

template<typename Typeclass, typename Class> \

struct typeclass_instance_helper

#define TYPECLASS_INSTANCE_TEMPLATE(template_decl, template_args, class) \

template<typename _typeclass, ONLY template_decl> \

struct instance : typeclass_instance_helper<_typeclass, ONLY template_args> \

#define INSTANCE_TEMPLATE(template_decl, template_args, typeclass, class) \

template<ONLY template_decl> \

struct typeclass_instance_helper<typeclass<ONLY template_args>, class> \

: public typeclass<ONLY template_args> \

::template instance<typeclass<ONLY template_args>, class> \

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

Type erasure

struct hashable_definition {

using hash = std::size_t () const;

DEFINE_TYPECLASS(hashable, hash);

DEFAULT_INSTANCE(hashable, T) {

static std::size_t hash(const T & t) SFINAE_FUNCTION(

return std::hash<T>()(t);

auto hash(const T & t) SFINAE_FUNCTION(tc_instance<hashable, T>::hash(t));

IntroOld ways

InterludesNew way

Type erasure

IntroOld ways

InterludesNew way

Type erasure

IntroOld ways

InterludesNew way

Type erasure

IntroOld ways

InterludesNew way

Type erasure

hashable::erased erased = 123;

erased.hash();

hash(erased);

int foo = 456;

hashable::erased_ref ref = foo;

ref.hash();

foo = 789;

hash(erased_ref);

IntroOld ways

InterludesNew way

Type erasure

erased.hash();

hash(erased);

int foo = 456;

ref.hash();

foo = 789;

hash(erased_ref);

IntroOld ways

InterludesNew way

Type erasure

erased.hash();

hash(erased);

int foo = 456;

ref.hash();

foo = 789;

hash(erased_ref);

IntroOld ways

InterludesNew way

Type erasure

erased.hash();

hash(erased);

int foo = 456;

ref.hash();

foo = 789;

hash(erased_ref);

IntroOld ways

InterludesNew way

Type erasure

erased.hash();

hash(erased);

int foo = 456;

ref.hash();

foo = 789;

hash(erased_ref);

IntroOld ways

InterludesNew way

Type erasure

erased.hash();

hash(erased);

int foo = 456;

ref.hash();

foo = 789;

hash(erased_ref);

IntroOld ways

InterludesNew way

Type erasure

erased.hash();

hash(erased);

int foo = 456;

ref.hash();

foo = 789;

hash(erased_ref);

IntroOld ways

InterludesNew way

Type erasure

DEFINE_TYPECLASS(hashable); // reflexpr magic to enumerate the members

IntroOld ways

InterludesNew way

Type erasure

// now with added function reflection!

struct hashable_definition

std::size_t hash() const;

with proper reflection, P0665, and Herb Sutter’s P0707 a.k.a ”metaclasses”, I’llbe able to drop (almost) ALL the macros

that’d be great

SG7 is on it!

C++23/26 timeframe /

IntroOld ways

InterludesNew way

Type erasure

that’d be great

SG7 is on it!

IntroOld ways

InterludesNew way

Type erasure

that’d be great

SG7 is on it!

IntroOld ways

InterludesNew way

Type erasure

that’d be great

SG7 is on it!

IntroOld ways

InterludesNew way

Type erasure

that’d be great

SG7 is on it!

IntroOld ways

InterludesNew way

Crash course in C++20 conceptsGenerating Concepts for typeclassesVirtual concepts

Outline

1. Introduction

3. Interludes

IntroOld ways

InterludesNew way

Crash course in C++20 concepts

concept True = true;

concept HasFoo = requires(T t) {

t.foo();

concept HasFooVoidReturn = requires(T t) {

{ t.foo() } -> void;

IntroOld ways

InterludesNew way

t.foo();

IntroOld ways

InterludesNew way

t.foo();

IntroOld ways

InterludesNew way

Generating Concepts for typeclasses

template<typename T, typename Return, typename... Args>

concept HasFunctionFoo = requires(T t, Args... args) {

{ t.foo(args...) } -> Return;

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

template<typename T, typename FuncType>

requires explode<FuncType, HasFunctionFoo, T>::...???

IntroOld ways

InterludesNew way

concept HasFunctionFoo = false;

concept HasFunctionFoo<T, Return (Args...)>

= requires(T t, Args... args) {

error: specialization of variable concept ’template⟨class T, class FuncType⟩concept const bool HasFoo⟨T, FuncType⟩’

IntroOld ways

InterludesNew way

concept HasFunctionFoo = false;

concept HasFunctionFoo<T, Return (Args...)>

= requires(T t, Args... args) {

error: specialization of variable concept ’template⟨class T, class FuncType⟩concept const bool HasFoo⟨T, FuncType⟩’

IntroOld ways

InterludesNew way

template<typename... Ts>

using has_foo_wrapped = std::bool_constant<HasFunctionFoo<Ts...>>;

concept Fooable = std::conjunction_v<has_foo_wrapped<T>, ...>;

IntroOld ways

InterludesNew way

template<typename... Ts>

using has_foo_wrapped = std::bool_constant<HasFunctionFoo<Ts...>>;

concept Fooable = std::conjunction_v<has_foo_wrapped<T>, ...>;

IntroOld ways

InterludesNew way

Virtual concepts

https://github.com/andyprowl/virtual-concepts

void print(const std::vector<Shape *> & v) { // a template

for (const auto & s : v) {

std::cout << s->get_area() << " ";

void print(const std::vector<virtual Shape *> & v) { // not a template

IntroOld ways

InterludesNew way

Virtual concepts

https://github.com/andyprowl/virtual-concepts

void print(const std::vector<Shape *> & v) { // a template

void print(const std::vector<virtual Shape *> & v) { // not a template

IntroOld ways

InterludesNew way

Future directions for type erasure wrappers

actually make a use of abominable function types

actually generate C++20 concepts for this (though I’m not 100% convinced this’llactually improve anything)

allow overloading of the erased functions

use Louis Dionne’s Dyno as a backend

IntroOld ways

InterludesNew way

actually generate C++20 concepts for this

(though I’m not 100% convinced this’llactually improve anything)

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

Summary

C++20 concepts need concept maps.

C++20 concepts need type erasure support.

Reflection will change the face of metaprogramming in C++,

More constexpr goodies are coming your way Soon (tm). (Dynamic allocation!)

IntroOld ways

InterludesNew way

Summary

IntroOld ways

InterludesNew way

Summary

IntroOld ways

InterludesNew way

Summary

IntroOld ways

InterludesNew way

Related (more-or-less) talks

”Meta; Thoughts on generative C++”, Herb Sutter, CppCon 2017:https://www.youtube.com/watch?v=4AfRAVcThyA

”Runtime Polymorphism: Back to the Basics”, Louis Dionne, CppCon 2017:https://www.youtube.com/watch?v=gVGtNFg4ay0

”Customization points that suck less”, yours truly, C++Now 2017, for the gorydetails of macro metaprogramming:https://www.youtube.com/watch?v=LC7BuYeDezQ

IntroOld ways

InterludesNew way

Questions and Answers

Thank you! (But wait, there’s slightly more!)

IntroOld ways

InterludesNew way

Questions and Answers

Thank you! (But wait, there’s slightly more!)

IntroOld ways

InterludesNew way

The C++ Standards Committee near you

the C++ Standards Committee is a group of volunteers who shape the way C++will look like in the future

it’s a volunteer effort, which means: if you want something changed, please writea paper! (this is a very polite way of saying ”patches welcome”)

anybody who attends the meeting has a vote in the working subgroups, that is:Evolution for the core language’s future, Library Evolution for the library, Core andLibrary working groups which maintain the wording of the standard, and variousstudy groups dedicated to specific topics

only P-member countries get a vote on actually approving (or rejecting) featuresthat made it through the subgroups, and approving or rejecting the finaldocuments

IntroOld ways

InterludesNew way

it’s a volunteer effort, which means: if you want something changed, please writea paper!

(this is a very polite way of saying ”patches welcome”)

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

Poland is currently an O-member, which means we’re formally recognized andhave some vote on the final document, but it’s not as good as P-membership

the national subcommittee related to the C++ committee is not very interested inC++, which means it’s hard to get quorum and actually cast a national vote

until that changes, chances of becoming a P-member are small

if your company (including personal businesses) is interested in helping with thedevelopment of the standard and giving Poland a stronger voice – please cometalk with me during the break (no direct personal participation in face-to-facemeetings required, but it’s always welcome!)

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

if your company (including personal businesses) is interested in helping with thedevelopment of the standard and giving Poland a stronger voice – please cometalk with me during the break

(no direct personal participation in face-to-facemeetings required, but it’s always welcome!)

IntroOld ways

InterludesNew way

IntroOld ways

InterludesNew way

The End.

customization points that suck less...makes it impossible to include a header containing a...

Documents