Extracting parameter pack from base class | Together C & C++ | Page 1

twilit jacinth Jan 16, 2023, 3:04 AM

#

I have this: ```cpp
template <typename... T>
struct system {
using components_t = std::tuple<T...>;
}

template <typename... T>
struct query {}

template <typename S>
system_id create_system() {
return create_system<S>(std::make_index_sequence<std::tuple_size_v<typename S::components_t>> {});
}

template <typename S, size_t... I>
system_id create_system(std::index_sequence<I...>) {
using components_t = typename S::components_t;
static_assert(std::is_base_of_v<system<std::tuple_element_t<I, components_t>...>, S>, "system must derive from system");
auto query_instance = query<std::tuple_element_t<I, components_t>...>();
}```

I used chatGPT to get here, and it works, but it seems awkward, is there a better way of doing this? Do i really need to store the T... in a tuple? And use a helper function with index_sequence to create a new parameter pack from the tuple with I and tuple_element_t? I feel like there should be a more straightforward way...

pastel parcelBOT Jan 16, 2023, 3:04 AM

#

When your question is answered use !solved to mark the question as resolved.

Remember to ask specific questions, provide necessary details, and reduce your question to its simplest form. For tips on how to ask a good question run !howto ask.

proud dagger Jan 16, 2023, 3:16 AM

#

what is this actually supposed to achieve?

#

this seems convoluted af ^^

#

is this just about creating a query<T...> with T... that match those of the system<T...>?

twilit jacinth Jan 16, 2023, 3:19 AM

#

yes, yes it is

proud dagger Jan 16, 2023, 3:19 AM

#

i would question whether that really is a problem you should be having in the first place.

twilit jacinth Jan 16, 2023, 3:19 AM

#

without making the caller of create_system pass each component type of the system, i want them to only have to pass the type of the overall system

proud dagger Jan 16, 2023, 3:20 AM

#

if there's this inherent dependency between those two, why not give the system a member function that creates the query?

twilit jacinth Jan 16, 2023, 3:20 AM

#

systems look like this: ```cpp
struct movement_system : public system<position, const velocity> {
void run(ctx_t& ctx, query_t& query) override {
for (auto [entity, position, velocity] : query) {
// move
}
}
};


I need to register this system with the world (`create_system`) so it can be called. When registering, i need to create a query with the same `<position, const velocity>`

proud dagger Jan 16, 2023, 3:27 AM

#

well, simplest would be to just give system a member function that creates the query

#

problem solved

twilit jacinth Jan 16, 2023, 3:28 AM

#

proud dagger if there's this inherent dependency between those two, why not give the system a...

originally i was trying to leave the job of creating queries up to the world instead, in case i end up caching/batching/adding options/etc. but yeah, if i just made the queries inside of the system it would be a lot easier

#

i could have the system call world.create_query, which would solve both those issues, but would then create a circular dependency

proud dagger Jan 16, 2023, 3:30 AM

#

you could also do it using a helper with partial specialization

#

but yeah

#

i'm not sure what that would get you over just doing it in the system

twilit jacinth Jan 16, 2023, 3:31 AM

#

yeah i guess really i should just do it that way for now. if i wanna get crazy with queries it would probably make more sense to just make a query_manager class, and both the world and system could have access to it, solving the circular dependency

#

but im def not doing anything fancy for awhile/ever so i should probably just keep it simple lol

#

thanks for the xy reminder. thats a huge problem when using chatgpt and not people, you go down these rediculous rabbit holes

#

at least i understand weird template stuff slightly more i guess

pastel parcelBOT Jan 16, 2023, 3:38 AM

#

@twilit jacinth Has your question been resolved? If so, run !solved :)

proud dagger Jan 16, 2023, 3:45 AM

#

fwiw, here's the simpler way to achieve what you were trying to do:

template <typename... T>
struct system {};

template <typename... T>
struct query {}

template <typename S>
struct query_type;

template <typename... T>
struct query_type<system<T...>> { using type = query<T...>; };

template <typename S>
system_id create_system() {
    auto query_instance = typename::query_type::type<S>();

    …
}

#

@twilit jacinth

twilit jacinth Jan 16, 2023, 3:47 AM

#

holy shit that makes so much more sense

#

i didnt think about using a specialization like that to grab the types from system. thanks!

proud dagger Jan 16, 2023, 3:48 AM

#

np ^^

#

it's kinda becoming a lost art these days, it's just constexpr everything, people forget about the power of declarative programming 😛

twilit jacinth Jan 16, 2023, 3:50 AM

#

when i started cpp i thought it was hard because of having to manually manage memory. nope the hard part of c++ is the crazy new typing features they are adding every update. c++ typing system is so similar to typescripts at this point

final robin Jan 16, 2023, 3:56 AM

#

the type system is the coolest part

#

and this stuff isnt really new

#

its the classic way to do things

#

but yea they do add a lot of complicated features

#

i like it that way tho

chrome geyser Jan 16, 2023, 3:57 AM

#

twilit jacinth when i started cpp i thought it was hard because of having to manually manage me...

worth pointing out that dot's solution is valid C++11, and similar techniques (just without the variadic) was used in C++98

#

on another note, if you're doing this kinda stuff then I recommend Boost.Mp11 (or one of the many other metaprogramming libraries that exist)

twilit jacinth Jan 16, 2023, 3:59 AM

#

Yeah i didnt mean dot's solution was new or difficult, i just meant the other stuff clouding it like all the sfinae/concept stuff

#

i should really take some time to properly learn them instead of trying to cobble knowledge together from a million different stackoverflow answers

final robin Jan 16, 2023, 4:00 AM

#

sfinae also isnt really new

chrome geyser Jan 16, 2023, 4:00 AM

#

template <typename... T>
struct system {};

template <typename... T>
struct query {};

template <typename S>
system_id create_system() {
  using namespace boost::mp11;
  auto query_instance = mp_rename<S, query>{};
  // ...
}

final robin Jan 16, 2023, 4:01 AM

#

twilit jacinth i should really take some time to properly learn them instead of trying to cobbl...

yea write projects involving heavy metaprogramming

#

i got it really fast that way

#

the same goes for any concept tbf

twilit jacinth Jan 16, 2023, 4:02 AM

#

should i learn sfinae? or concepts? or do i need to learn both? are they even mutually exclusive or do you need to use both?

chrome geyser Jan 16, 2023, 4:02 AM

#

if you're using C++20, then 99% of the time you'll be wanting concepts instead of SFINAE stuff

twilit jacinth Jan 16, 2023, 4:02 AM

#

yeah i use cpp20 99% of the time

chrome geyser Jan 16, 2023, 4:02 AM

#

they can do pretty much everything SFINAE can but better

final robin Jan 16, 2023, 4:02 AM

#

i rarely use sfinae

proud dagger Jan 16, 2023, 4:03 AM

#

chrome geyser if you're using C++20, then 99% of the time you'll be wanting concepts instead o...

is there any case SFINAE can do that constraints can't?

final robin Jan 16, 2023, 4:03 AM

#

you can avoid it with other tricks internally

#

ofc when its exposed to the user directly you may have to use it

chrome geyser Jan 16, 2023, 4:03 AM

#

SFINAE can have better compile times currently

proud dagger Jan 16, 2023, 4:03 AM

#

twilit jacinth yeah i use cpp20 99% of the time

basically, SFINAE is just the pre C++20 hack to do a limited version of what constraints do.

proud dagger Jan 16, 2023, 4:04 AM

#

chrome geyser SFINAE can have better compile times currently

huh?

chrome geyser Jan 16, 2023, 4:04 AM

#

otherwise I don't really know of anything where SFINAE (as the technique itself) can be used as an improvement

twilit jacinth Jan 16, 2023, 4:05 AM

#

proud dagger basically, SFINAE is just the pre C++20 hack to do a limited version of what con...

will sfinae stuff be depricated at some point?

final robin Jan 16, 2023, 4:05 AM

#

chrome geyser SFINAE can have better compile times currently

unsurprising

twilit jacinth Jan 16, 2023, 4:05 AM

#

if its objectively worse?

final robin Jan 16, 2023, 4:05 AM

#

no?

#

how would you even go about that

proud dagger Jan 16, 2023, 4:05 AM

#

twilit jacinth will sfinae stuff be depricated at some point?

SFINAE is not really a language feature. it's more like an emergent property of the interaction of various features.

twilit jacinth Jan 16, 2023, 4:05 AM

#

ah

final robin Jan 16, 2023, 4:05 AM

#

yea

chrome geyser Jan 16, 2023, 4:05 AM

#

proud dagger huh?

it depends on the particular context, but I have measured cases where using expression SFINAE in a return type had better throughput than expressing the same thing using a concept or requires-expression

proud dagger Jan 16, 2023, 4:05 AM

#

so no, it's not gonna be deprecated

proud dagger Jan 16, 2023, 4:06 AM

#

chrome geyser it depends on the particular context, but I have measured cases where using expr...

ok, that seems kinda strange tbh, but i can see how that might be the case in some cases with simple expressions. but SFINAE usually ends up depending on huge amounts of traits that all need to be instantiated and stuff…

chrome geyser Jan 16, 2023, 4:07 AM

#

depends what you mean by SFINAE too

#

enable_if I don't see being useful anywhere anymore ever

#

but SFINAE is more than just enable_if

final robin Jan 16, 2023, 4:07 AM

#

proud dagger SFINAE is not really a language feature. it's more like an emergent property of ...

theres a few things that the iso wants to make invalid but cant be done easily for the same reason

#

without just saying "dont do this"

#

which would also be valid

chrome geyser Jan 16, 2023, 4:07 AM

#

(arguably, requires-clauses are a particular form of SFINAE too 😛 )

proud dagger Jan 16, 2023, 4:07 AM

#

SFINAE kinda exists for good reasons, it wouldn't make sense to make that invalid

final robin Jan 16, 2023, 4:08 AM

#

ye

proud dagger Jan 16, 2023, 4:08 AM

#

chrome geyser (arguably, `requires`-clauses are a particular form of SFINAE too 😛 )

well, requires is more general, you can use it on templated entities that are not templates themselves and stuff

final robin Jan 16, 2023, 4:09 AM

#

chrome geyser (arguably, `requires`-clauses are a particular form of SFINAE too 😛 )

in the same vein but since they have different rules i wouldnt call them equivalent

chrome geyser Jan 16, 2023, 4:09 AM

#

yeah, I'm not saying they're equivalent

final robin Jan 16, 2023, 4:09 AM

#

ik

chrome geyser Jan 16, 2023, 4:09 AM

#

just that when substituting parameters in, failed requires-clauses also cause a substitution failure but no error

#

so in the most literal sense of the word...

final robin Jan 16, 2023, 4:09 AM

#

true true

proud dagger Jan 16, 2023, 4:09 AM

#

but yeah, raw sfinae without relying on the classic machinery, i can see that that might sometimes be faster than going into the constraints checking path

final robin Jan 16, 2023, 4:10 AM

#

but its become attached to something specific

#

so it might be confusing for new metaprogrammers 😛

chrome geyser Jan 16, 2023, 4:10 AM

#

yeah, which I guess is why I was thinking about what "SFINAE" meant in this context

#

a lot of people by SFINAE just mean enable_if (or related tricks), which is definitely no longer a thing IMO

#

but there are uses for it outside of that too

proud dagger Jan 16, 2023, 4:11 AM

#

yeah, that's what i was mainly thinking of because that's what most people usually mean ^^

final robin Jan 16, 2023, 4:11 AM

#

chrome geyser a lot of people by SFINAE just mean `enable_if` (or related tricks), which is de...

it shouldnt be at least
i bet people will still use it tho lol

chrome geyser Jan 16, 2023, 4:11 AM

#

unless they're supporting pre-C++20, they deserve all the pain they inflict upon themselves

proud dagger Jan 16, 2023, 4:11 AM

#

i am kinda surprised still that constraints would be slower than doing the same thing with sfinae. might just be an artifact of how current implementations work?

final robin Jan 16, 2023, 4:12 AM

#

i assume it is

#

will probably be ironed out later

chrome geyser Jan 16, 2023, 4:12 AM

#

possibly yeah; I imagine that perf will improve over time

proud dagger Jan 16, 2023, 4:12 AM

#

at least i don't really see any inherent reason why constraints would have to be slower

chrome geyser Jan 16, 2023, 4:12 AM

#

Using concepts will always be slower because that does more work though

proud dagger Jan 16, 2023, 4:12 AM

#

sure

chrome geyser Jan 16, 2023, 4:12 AM

#

but normal constraints are different

final robin Jan 16, 2023, 4:12 AM

#

i think its like why gcc is slower than clang
its just how they do X, its not intrinsically linked to it

proud dagger Jan 16, 2023, 4:12 AM

#

well, i mean, i would hope that concepts would be faster than doing the equivalent thing via traits and stuff

chrome geyser Jan 16, 2023, 4:13 AM

#

Depends on the trait 😛 A lot of concepts are implemented in terms of traits, after all..

proud dagger Jan 16, 2023, 4:13 AM

#

yes, i'm thinking constraints that don't rely on traits

chrome geyser Jan 16, 2023, 4:13 AM

#

and they have additional partial ordering/normalisation to do

proud dagger Jan 16, 2023, 4:13 AM

#

yes but they should cut down a lot on template instantiations

chrome geyser Jan 16, 2023, 4:14 AM

#

Compilers these days are pretty good at traits being implemented as compiler builtins too

proud dagger Jan 16, 2023, 4:14 AM

#

yeah

final robin Jan 16, 2023, 4:14 AM

#

yep

#

no more manual integer_sequence ing

#

probably my favorite since i use it so much

proud dagger Jan 16, 2023, 4:15 AM

#

just saying, if you take a random concept and compare that to implementing the same thing via a traits class and sfinae, i would hope that the concept wins or at least that there be no reason why it would inherently have to be slower 🤔

#

i can very much see why it currently would be

#

we've been doing traits for the last 30 years after all

chrome geyser Jan 16, 2023, 4:15 AM

#

GCC13 even will have a builtin for tuple_element too (well, probably), which will be handy given how often tuples end up getting used in metaprogramming

proud dagger Jan 16, 2023, 4:16 AM

#

built-in tuple when 😛

final robin Jan 16, 2023, 4:16 AM

#

i ended up writing my own tuple to avoid the problems with the standards implementation

chrome geyser Jan 16, 2023, 4:16 AM

#

proud dagger built-in `tuple` when 😛

Let me introduce you to struct 😛

final robin Jan 16, 2023, 4:16 AM

#

there are even faster ones but its my baby

#

i have to use it

proud dagger Jan 16, 2023, 4:16 AM

#

chrome geyser Let me introduce you to `struct` 😛

if only you could expand template parameter packs into a list of class members…

chrome geyser Jan 16, 2023, 4:16 AM

#

maybe in C++26

proud dagger Jan 16, 2023, 4:17 AM

#

class member packs when

chrome geyser Jan 16, 2023, 4:17 AM

#

it is proposed

proud dagger Jan 16, 2023, 4:17 AM

#

oh

final robin Jan 16, 2023, 4:17 AM

#

proud dagger if only you could expand template parameter packs into a list of class members…

🤞 this happens soon

proud dagger Jan 16, 2023, 4:17 AM

#

nice

#

didn't know

final robin Jan 16, 2023, 4:17 AM

#

theres a massive proposal with a bunch of metaprogramming features

chrome geyser Jan 16, 2023, 4:17 AM

#

There's also a clang fork with an impl already

proud dagger Jan 16, 2023, 4:17 AM

#

sweet

final robin Jan 16, 2023, 4:17 AM

#

i think pack indexing will also be good

#

its a pain in the ass to deal with rn

proud dagger Jan 16, 2023, 4:17 AM

#

then yeah, maybe tuple can actually be implemented as a library feature in a sane way eventually

chrome geyser Jan 16, 2023, 4:18 AM

#

pack indexing? You mean, forward_as_tuple and then std::get

#

(/s)

final robin Jan 16, 2023, 4:18 AM

#

thank god i didnt have to write it out lmao

#

pack syntax isnt exactly terse

#

also speaking of speed i had a theory about clangs speed and how it affects template behaviour
explained here https://twitter.com/888IGHTFOLD/status/1613324366141394944
do you know anything about this @chrome geyser

eightfold (@888IGHTFOLD)

Interesting bug I found:
this compiles,
https://t.co/fD5L4581ld
this does not.
https://t.co/Lii4bU9nYZ
[https://t.co/uA15R3eEMS] implies this is in fact ifndr, and msvc and gcc both get this wrong. This is interesting because it shows how different compilers do instantiation.

chrome geyser Jan 16, 2023, 4:22 AM

#

(I'll ignore that it's impossible for any compiler to ever get something being IFNDR "wrong", given an IFNDR literally means that the compiler can do whatever the hell it likes with it)

#

But yeah, it's well known that different compilers perform different amounts of speculative template instantiation in places; there are some rules around what is allowed to produce errors though

final robin Jan 16, 2023, 4:22 AM

#

well i meant more how it instantiated it instead of giving an error

#

which is ifndr, not instantiating it and giving an error would be correct

proud dagger Jan 16, 2023, 4:23 AM

#

wdym

final robin Jan 16, 2023, 4:23 AM

#

(my understanding could be wrong ofc)

proud dagger Jan 16, 2023, 4:23 AM

#

if this is ifndr then it's ifndr

#

there's no correct behavior then

final robin Jan 16, 2023, 4:23 AM

#

it shouldnt pick a specialization

#

theres no way to deduce it

#

it shouldnt even compile

final robin Jan 16, 2023, 4:25 AM

#

chrome geyser But yeah, it's well known that different compilers perform different amounts of ...

its interesting
generally doesnt affect how things work except with weird things like lambdas in template parameters

#

im not even sure what the correct behaviour is when dealing with that
clang only does it the expected way in main

proud dagger Jan 16, 2023, 4:31 AM

#

ok it's quite late, i'm not exactly sure i understand what the issue is supposed to be with that example

final robin Jan 16, 2023, 4:32 AM

#

in c++20 it should generate 2 functions when you use the comparison operator overloads

#

and when you have multiple derived classes that means there are duplicate overloads

#

it shouldnt pick an overload because there is more than one "best fit"

proud dagger Jan 16, 2023, 4:35 AM

#

ok so it is just that. i was thinking there's some supposed issue with instantiation order or smth there. and i kinda fail to see one.

final robin Jan 16, 2023, 4:36 AM

#

yea but i was theorizing about why gcc and msvc both find a match

proud dagger Jan 16, 2023, 4:36 AM

#

because of a bug in their implementation of rewritten operator candidates i guess 😛

final robin Jan 16, 2023, 4:37 AM

#

in relation to other things
rather than read the source i was trying to link other quirks of the compilers to get an idea of whats actually going wrong

#

but its just a theory

#

a compiler theory

proud dagger Jan 16, 2023, 4:37 AM

#

i mean, you could just debug gcc to see what exactly is going wrong 😛

#

it's kinda funny in msvc, if you change the dur<Foo<T, Other>> to dur<Foo>, it fails

#

so the injected class name is somehow special

#

i don't even want to know how that makes a difference

final robin Jan 16, 2023, 4:39 AM

#

yea that was what got me interested

#

my idea was when you do that it makes it regenerate them (or something along those lines)
so it then picks the best match for that class because it only sees those at the time

#

but honestly idk

#

its funny

proud dagger Jan 16, 2023, 4:40 AM

#

yeah this seems like a really weird bug

final robin Jan 16, 2023, 4:41 AM

#

i dont feel like submitting a bug report to gcc

#

im sure someone else has already found it

proud dagger Jan 16, 2023, 4:47 AM

#

here's a simplified repro: https://godbolt.org/z/eoa8con3Y

final robin Jan 16, 2023, 4:48 AM

#

this leaves out the bug tho

proud dagger Jan 16, 2023, 4:49 AM

#

the bug is that this compiles no?

final robin Jan 16, 2023, 4:49 AM

#

yea

#

hmm

final robin Jan 16, 2023, 4:50 AM

#

proud dagger it's kinda funny in msvc, if you change the `dur<Foo<T, Other>>` to `dur<Foo>`, ...

im not sure if i should bring this part

#

its not entirely relevant to this issue but it could help?

#

idk

proud dagger Jan 16, 2023, 4:57 AM

#

no idea

twilit jacinth Jan 16, 2023, 5:06 AM

#

proud dagger fwiw, here's the simpler way to achieve what you were trying to do: ```cpp templ...

just got around to trying this so i can understand how it works, but i get an error when trying to pass a subclass of system to create_system

struct movement : public system<int, bool> { };
create_system<movement>(); // Implicit instantiation of undefined template 'query_type<movement>'
create_system<system<int, bool>>(); // Works```

#

im not sure if you need to do something extra for the template specialization of query_type to also match derived types?

proud dagger Jan 16, 2023, 5:08 AM

#

yeah this doesn't handle subclasses

twilit jacinth Jan 16, 2023, 5:10 AM

#

oh, got it. is it possible for a specialization to handle this? i tried playing around with using concepts for it but i dont understand them enough to apply them in this situation

chrome geyser Jan 16, 2023, 5:10 AM

#

You could use concepts to write a specialisation for any derived type

final robin Jan 16, 2023, 5:11 AM

#

twilit jacinth im not sure if you need to do something extra for the template specialization of...

yea templates do pattern matching
so you would need to add a new case for derived types

#

or that

chrome geyser Jan 16, 2023, 5:11 AM

#

However, you could also do mp_rename style for any type of any kind at all, as long as the parameter packs match

#

which it seems is what you want

#

template <typename L, template <typename...> typename C>
struct rename;

template <typename L, typename... Ts, template <typename...> typename C>
struct rename<L<Ts...>, C> { using type = C<Ts...>; };

template <typename L, template <typename...> typename C>
using rename_t = rename<L, C>::type;

// ...

template <typename S>
system_id create_system() {
  auto query_instance = rename_t<S, query>{};
  // ...
}

#

(these kinds of nice tricks are why I was recommending Boost.Mp11 earlier)

#

(fixed typo)

proud dagger Jan 16, 2023, 5:15 AM

#

this doesn't handle the base class case tho right?

chrome geyser Jan 16, 2023, 5:15 AM

#

Oh wait, I see, I misunderstood

proud dagger Jan 16, 2023, 5:15 AM

#

i mean, i would generally try to avoid doing things like that where behavior depends on a type deriving from some base class

#

ime that's usually a bad idea

chrome geyser Jan 16, 2023, 5:17 AM

#

You could do this by using an entirely different trick which might be neater

proud dagger Jan 16, 2023, 5:17 AM

#

really the simplest solution here is to just put the method to create the query into the system class, then any derived class will automatically have it

chrome geyser Jan 16, 2023, 5:17 AM

#

template <typename... T>
struct system {
  // define the query type here!
  using query_type = query<T...>;

  // ...
};

#

yeah

#

and then to get that you can just typename S::query_type and that'll always work

proud dagger Jan 16, 2023, 5:18 AM

#

this just makes a lot more sense than having external code try to inspect types in order to figure out whether to apply magic or not

twilit jacinth Jan 16, 2023, 5:18 AM

#

yeah that makes a lot more sense

proud dagger Jan 16, 2023, 5:19 AM

#

the other way round is just super brittle

#

like, what if the system is a private or protected base

#

should that work or not?

#

it's just… not great

chrome geyser Jan 16, 2023, 5:20 AM

#

without reflection there's no good way of getting the precise template instantiation of the base class either, I don't think

proud dagger Jan 16, 2023, 5:20 AM

#

yeah, i also don't think you can really deduce it in that case

twilit jacinth Jan 16, 2023, 5:20 AM

#

keeping the query_type inside the system makes a lot of sense, i like that

chrome geyser Jan 16, 2023, 5:21 AM

#

yeah, either that or a (static?) function to create the correct object of that type as dot suggested

proud dagger Jan 16, 2023, 5:21 AM

#

this is actually one reason i'm already dreading the moment when we have reflection: because people will just start to do stuff like that, and be able to do so, even when it's a really bad idea.

final robin Jan 16, 2023, 5:21 AM

#

hehe https://godbolt.org/z/Ezr84cKza

Compiler Explorer - C++ (x86-64 clang (reflection))

namespace rfl = std::experimental::reflect;

// General utilities
struct custom_exception : std::exception
{
custom_exception() : what_v("Exception thrown.") {}
custom_exception(const char* what_v) : what_v(what_v) {}
custom_exception(const custom_exception& e) : what_v(e.what_v) {}

const char* what() const noexcept {
    r...

#

im excited for reflection
the good stuff will be cool and the bad stuff will be fun to read

chrome geyser Jan 16, 2023, 5:22 AM

#

I mean, I'm less concerned about that because with reflection the whole "trace the base classes and do magic" becomes a whole lot less magic and IMO less of a bad idea

#

in this case when you can invert the responsibilities still a good thing to do so, though

final robin Jan 16, 2023, 5:23 AM

#

im more worried about the current syntax they chose

chrome geyser Jan 16, 2023, 5:23 AM

#

that is, reflection will allow you to do it the other way around correctly without awkward compromises

final robin Jan 16, 2023, 5:23 AM

#

and the speed of it

chrome geyser Jan 16, 2023, 5:23 AM

#

eh, I think the syntax is fine

final robin Jan 16, 2023, 5:23 AM

#

have you really messed around with it?

#

it gets very painful with any amount of complexity

#

the revised syntax does look more promising but idk

#

its not there yet

twilit jacinth Jan 16, 2023, 5:24 AM

#

maybe a stupid idea, but just trying to wrap my head around this stuff, would something like this be possible? ```cpp
template <typename F>
using forward_args_t = F<T...>;

i cant seem to get it to work but maybe i have the syntax wrong?

chrome geyser Jan 16, 2023, 5:24 AM

#

I'm talking about the revised syntax here btw

#

(which is what I thought you meant by "the current syntax they chose", not the syntax from the 2018 TS or whatever)

final robin Jan 16, 2023, 5:24 AM

#

final robin hehe https://godbolt.org/z/Ezr84cKza

this 🤣

#

but yea ive messed around with the new stuff too

#

and its better

chrome geyser Jan 16, 2023, 5:25 AM

#

twilit jacinth maybe a stupid idea, but just trying to wrap my head around this stuff, would so...

no, because what's T here?

final robin Jan 16, 2023, 5:25 AM

#

but we really need more metaprogramming syntactic sugar to have it be nice to use

twilit jacinth Jan 16, 2023, 5:25 AM

#

chrome geyser no, because what's `T` here?

sorry, would be in the system class: cpp template <typename... T> struct system { template <typename F> using forward_args_t = F<T...>; }

final robin Jan 16, 2023, 5:25 AM

#

this is possible

#

only problem is it would be system<...>::template forward_args_t<F>

chrome geyser Jan 16, 2023, 5:26 AM

#

Yeah, that's fine; doing typename S::template forward_args_t<query> will give you query<stuff>

final robin Jan 16, 2023, 5:26 AM

#

not the nicest looking but

#

would work

chrome geyser Jan 16, 2023, 5:26 AM

#

as you can see that's a bit awks though

final robin Jan 16, 2023, 5:26 AM

#

you would probably write a helper template for it

#

forward_args<F, ...>

proud dagger Jan 16, 2023, 5:27 AM

#

    template <template <typename...> typename F>
    using forward_args_t = F<T...>;

final robin Jan 16, 2023, 5:27 AM

#

would work too

chrome geyser Jan 16, 2023, 5:27 AM

#

ah yea, no that's needed

#

I read what I expected to be there not what actually was 😛

final robin Jan 16, 2023, 5:28 AM

#

mmm yea i think theres some newer stuff that lets you avoid that

chrome geyser Jan 16, 2023, 5:28 AM

#

not that I'm aware of

final robin Jan 16, 2023, 5:28 AM

#

but i may be confusing it with nttp

twilit jacinth Jan 16, 2023, 5:28 AM

#

ah ha yeah thats what i was missing, never used template templates before

final robin Jan 16, 2023, 5:28 AM

#

template <typename T>
struct X {};

template <X x>
using ... = something<x>;

chrome geyser Jan 16, 2023, 5:28 AM

#

yeah, that's just that NTTPs can do CTAD

#

good times

final robin Jan 16, 2023, 5:29 AM

#

except apple clang which SUX

#

i tried to do the string literal type interning trick on it but it was giving me shit for trying to use it

proud dagger Jan 16, 2023, 5:30 AM

#

chrome geyser yeah, that's just that NTTPs can do CTAD

honestly, when i first learned about this… it's hard to describe how it made me feel. it was a weird mix of wonder, relief, excitement, and absolute terror…

final robin Jan 16, 2023, 5:30 AM

#

my jaw just completely fell off

#

i had to tape it back on 🥲

chrome geyser Jan 16, 2023, 5:31 AM

#

Yeah, I saw this, and my first thought was "I have a dream" and proceeded to write some absolute jank

#

which wasn't helped by the fact that GCC had literally just added support for this and had all sorts of weird bugs and no text editor knew what on earth this was talking about

#

but... it's handy stuff, if you're into completely nonsense TMP

final robin Jan 16, 2023, 5:32 AM

#

very much am

final robin Jan 16, 2023, 5:33 AM

#

chrome geyser which wasn't helped by the fact that GCC had literally just added support for th...

gcc also has the bug where they allowed non structural types

#

so you could use a std::array as a parameter for example

chrome geyser Jan 16, 2023, 5:33 AM

#

std::array is a structural type?

final robin Jan 16, 2023, 5:33 AM

#

not according to the compilers :P

chrome geyser Jan 16, 2023, 5:34 AM

#

thonk

final robin Jan 16, 2023, 5:34 AM

#

same goes for initializer_list

chrome geyser Jan 16, 2023, 5:34 AM

#

what on earth would make it non-structural?

#

initializer_list, fine, though that's compiler-dependent

final robin Jan 16, 2023, 5:34 AM

#

honestly... no clue
its probably the fact its a new feature

#

they havent worked out all the kinks

#

string_view was also acting funny

chrome geyser Jan 16, 2023, 5:34 AM

#

but std::array is specified as just ```cpp
template <typename T, std::size_t N>
struct array {
// either
T __data[N];

// or
T __data_0;
T __data_1;
// ...
T __data_n;
}

#

(and no implementation uses the second version 😛 )

final robin Jan 16, 2023, 5:35 AM

#

ye

proud dagger Jan 16, 2023, 5:35 AM

#

you're getting dangerously close here to reminding me that floats can be template parameters now

#

please don't

final robin Jan 16, 2023, 5:35 AM

#

but it seems like it doesnt consider it structural in template parameters

#

that could be a bug as well

#

i havent looked into this that much

#

just did a bit of testing on different compilers

chrome geyser Jan 16, 2023, 5:36 AM

#

;compile -std=c++20 ```cpp
#include <array>

template <auto x>
void foo() {}

int main() {
foo<std::array<int, 4>{}>();
}

untold shardBOT Jan 16, 2023, 5:36 AM

#

Compilation successful

No output.

chrome geyser Jan 16, 2023, 5:36 AM

#

seems fine ¯_(ツ)_/¯

final robin Jan 16, 2023, 5:36 AM

#

oh i think the problem was this

#

#include <array>

template <std::array x>
void foo() {}

int main() {
  foo<{ 1, 2, 3, 4 }>();
}

chrome geyser Jan 16, 2023, 5:37 AM

#

That's just a deduction problem I think

final robin Jan 16, 2023, 5:37 AM

#

it did figure out the type

#

but it wasnt a fan of it

chrome geyser Jan 16, 2023, 5:37 AM

#

final robin ```cpp #include <array> template <std::array x> void foo() {} int main() { f...

;compile -std=c++20

untold shardBOT Jan 16, 2023, 5:37 AM

#

Compilation successful

No output.

proud dagger Jan 16, 2023, 5:37 AM

#

-.-

final robin Jan 16, 2023, 5:37 AM

#

hold on lemme find the actual code

chrome geyser Jan 16, 2023, 5:38 AM

#

I win 😛

final robin Jan 16, 2023, 5:39 AM

#

#include <array>

template <std::array A>
constexpr auto arr_t = A;

auto a = arr_t<{1, 2, 3}>;

#

was based on the idea of str_t<"string literal here">;

chrome geyser Jan 16, 2023, 5:41 AM

#

final robin ```cpp #include <array> template <std::array A> constexpr auto arr_t = A; auto...

;asm -std=c++20

untold shardBOT Jan 16, 2023, 5:41 AM

#

Assembly Output

a:
  .long 1
  .long 2
  .long 3

chrome geyser Jan 16, 2023, 5:41 AM

#

¯_(ツ)_/¯

#

Looks like GCC10 fails though

#

(GCC 10 had a whole heap of other related bugs too though, all of which have been fixed since AFAIK)

final robin Jan 16, 2023, 5:42 AM

#

ye

#

also apple clang is basically clang 11.2
they need to get with the times fr

#

(gonna keep malding about how bad it is until they fix it)

#

https://godbolt.org/z/M844753rx hmm the error changed

Compiler Explorer - C++ (x86-64 clang 15.0.0)

template <std::array A>
constexpr auto arr_t = A;

auto a = arr_t<{1, 2, 3}>;

#

i might be confusing compilers

#

been a while

twilit jacinth Jan 16, 2023, 6:22 AM

#

ended up going with a query_t in the system struct. everything works great and now i can have both systems as structs or lambda functions 😄

thanks for all the help guys

#

!solved

#Extracting parameter pack from base class