hkaiser changed the topic of #ste||ar to: STE||AR: Systems Technology, Emergent Parallelism, and Algorithm Research | stellar-group.org | HPX: A cure for performance impaired parallel applications | github.com/STEllAR-GROUP/hpx | This channel is logged: irclog.cct.lsu.edu
hkaiser has quit [Quit: Bye!]
K-ballo1 has joined #ste||ar
K-ballo has quit [Ping timeout: 268 seconds]
K-ballo1 is now known as K-ballo
Yorlik has joined #ste||ar
K-ballo1 has joined #ste||ar
K-ballo has quit [Ping timeout: 272 seconds]
K-ballo1 is now known as K-ballo
hkaiser has joined #ste||ar
diehlpk_work has joined #ste||ar
<gnikunj[m]> hkaiser: srinivasyadav227 meeting in 8min?
<hkaiser> gnikunj[m]: yes
<gonidelis[m]> `template<typename T>
<gonidelis[m]> concept Addable = requires (T x) { x + x; };`
<gonidelis[m]> K-ballo what requirement is being defined here??
<gonidelis[m]> for x to be able to be added with itself?
<K-ballo> identity doesn't play a role in the type system
<K-ballo> two lvalues are being added
<K-ballo> lvalues of type T
<gonidelis[m]> yes but what is the requirement of the concept?
<K-ballo> that two lvalues of type T can be added.... or are you asking something else?
<K-ballo> (that you can call + on them, it doesn't actually have to mean addition)
<gonidelis[m]> ok yes
<gnikunj[m]> I guess he's asking about operator+ being defined for type T
<gonidelis[m]> thats what i was asking
<gonidelis[m]> yes yes
<gonidelis[m]> yes!
<gonidelis[m]> gnikunj: that
<K-ballo> the expression `x + x` has to be well-formed, that's what the requirement checks
<K-ballo> it could be defined not for T, but for some other thing convertible for T
<gonidelis[m]> god
<K-ballo> any way in which `x + x` compiles is enough
<K-ballo> the type `quote<T::template invoke>` is well formed
<gonidelis[m]> and when could it be well formed?
<gonidelis[m]> for example
<K-ballo> ...whenever it is well formed
<K-ballo> quote is declared, and it accepts as argument T::template invoke
<gonidelis[m]> weird I saw it being used with two arguments
<gonidelis[m]> it was like `invocable<Fun, Args>`
<gonidelis[m]> but this definition seems like it only defines for the object `T` to be invocable
<K-ballo> this is meta invocable (for types), you seem to be thinking of values
<gonidelis[m]> huh
<K-ballo> those are completely different invocable concepts, one for types and one for values
<gonidelis[m]> ok
<gonidelis[m]> so
<gonidelis[m]> but they are used the same way as you pointed out.
<gonidelis[m]> this should not be possible since they work in different level of abstraction
<gonidelis[m]> for ref
<K-ballo> namespace ns1 { concept Foo = ...; }
<K-ballo> namespace ns2 { concept Foo = ...; }
<gonidelis[m]> lol
<gonidelis[m]> where is it?
<gonidelis[m]> damn definition hunter
<gonidelis[m]> thanks
<gonidelis[m]> but still what is the purpose of a META_CONCEPT? U said its for types but that sound like regular concepts
<K-ballo> meta is eric's metaprogramming library
<gonidelis[m]> +1
<gonidelis[m]> will ask him
<K-ballo> not sure what the question even is
<K-ballo> they are all concepts, the purpose is the same, the difference is in what they require
<gonidelis[m]> you said meta concepts work on types, not values. The question is what is their difference with the regular c++20 concepts? For what I know regular concepts still refrain on the type properties
<gonidelis[m]> (also what is the purpose of a `template` keyword after `::` ? I 've seen it before but it's bugging me. `T::template invoke`
<K-ballo> all concepts work on types
<K-ballo> the concepts of meta, being a metapprograming library, will be type oriented (`typename` requirements)
<K-ballo> whereas value oriented requirements consist of expressions
<gonidelis[m]> alright now it makes more sense
<gonidelis[m]> `typename` requirements have to do with whether a type exists or not?
<gonidelis[m]> right
<gonidelis[m]> ?
<gonidelis[m]> so the META_CONCEPT def that I provided previously just checks if `quote<T::template invoke>` type exists
<gonidelis[m]> yes
<gonidelis[m]> now I gotta lean what `quote<T::template invoke>` means
<gonidelis[m]> I don't understand either `quote` or `T::template invoke`
<satacker[m]> There's a cpp reference page I came across for ::template as I didn't get it too before the latest PR. Hope you don't mind me sharing the link. "Dependent names - cppreference.com" https://en.cppreference.com/w/cpp/language/dependent_name
<gonidelis[m]> thanks Shreyas
<gonidelis[m]> yes!
<gonidelis[m]> i recall
<gonidelis[m]> thanks!
<gonidelis[m]> excellent
<gonidelis[m]> "disambiguator"
<K-ballo> "quoting" is turning the invoke template into a metafunction (type) that applies invoke
<K-ballo> `T::template invoke` is not a type, `quote<T::template invoke>` is a type
<K-ballo> applying arguments Args to `quote<T::template invoke>` is effectively equivlent to `T::template invoke<Args...>`
K-ballo1 has joined #ste||ar
K-ballo has quit [Ping timeout: 240 seconds]
K-ballo1 is now known as K-ballo
<gonidelis[m]> K-ballo: thanks!!
<gonidelis[m]> I am trying to grasp the purpose of Boost.MP. Could we for example use it entirely to develop HPX instead of utilizing bare-bone template techniques?
<gonidelis[m]> > All metafunction's arguments must be types (i.e. only type template parameters are allowed)
<gonidelis[m]> K-ballo how can you provide sth that is not a type as a template argument?
<gnikunj[m]> gonidelis: you mean `template <std::size_t some_value>`?
<gnikunj[m]> You can do it for arbitrary types too, `template <typename Foo, Foo f>`
<gnikunj[m]> `f` or `some_value` in this case is a template value and not a template type
<gonidelis[m]> Oh I was thinking during specialization
diehlpk_work has quit [Remote host closed the connection]
Yorlik has quit [Ping timeout: 255 seconds]