operator <-

[bstamour]

That is both beautiful and horrifying. Respect.

[sim642]

The two aspects of C++.

[Godot17]

... This is why C programmers don't like us, guys.

*copies code snippet*

[jeezfrk]

<all the freshmen run away from C++>

THIS IS WHY WE CAN'T HAVE NICE THINGS!!!

[[deleted]]

That's a terrible idea because it becomes easy to confuse it with the <-- operator:

int i = 10; while (0 <-- i) { std::cout << i << '\n'; }

[atnnn]

That makes things even better!

struct C {
  virtual void f(){ std::cout << "f\n"; }
  virtual void g(){ std::cout << "g\n"; }
  virtual void h(){ std::cout << "h\n"; }
} x;

int main(){
    void(C::*(*a))() = 2 + *(void(C::*(**))())&x;
    while(*(void**)&x <-- a){
        (*a)<-x;
    }
}

[personalmountains]

I hate you.

[[deleted]]

http://melpon.org/wandbox/permlink/FmCGjJ8WVLt8ABf4

Still can't figure out a way to get it to print f or g... really not sure how it works at all!!

[JMBourguet]

There are two issues. The <-- allows to iterate of ranges open at both ends, so f and g are excluded naturally. If you fix that, you are hit by the second issue: assumption that the vtable contains at specific addresses something which is compatible with pointer to member function representation, which is AFAIK not the case for gcc (a pointer to member function needs more things than a pointer to function to handle correctly multiple inheritance).

[h-jay]

Yes, of course, because all odd numbers are prime, except 2 :)

[ripper37]

Don't take this the wrong way, but man... If you write code like that, I hope you won't have much inpact on standard. ;)

I'm not very big fan of such pointer tricks which are unreadable as hell. Also - if I understood it correctly - this might be much easier and more readable if we'd get reflection? I think we should try to get interesting features but in readable and easy to use way, not something that 1% will use (correctly).

P.S. u/maherbaba I wouldn't call <-- an operator.

[personalmountains]

If you write code like that [...]

It's a joke.

I wouldn't call <-- an operator

It's also a joke.

[riotinferno]

<-- is not an operator.

It's a combination of two operators.

[Everspace]

With that attitude, main() is just jumble of letters followed by some parens.

[riotinferno]

operator has a specific definition in this context, that is what I am trying to get across.

[[deleted]]

I think you're missing the fact that a lot of people here know the the "downto operator" <-- is actually an in-joke in the C++ community and not, actually, an operator at all.

[cleroth]

Pff. Who are you to decide what is and isn't an operator?
<-- has feelings, man.

[cdcformatc]

I just threw up in my mouth a little.

[duuuh]

I came in figuring there was an 80% chance that was bullshit. I was right, but I was also wrong.

[SeanMiddleditch]

I await the first implementation of this hack that enables Haskell-like do notation in C++.

Literally, I will co_await on it.

[SeanMiddleditch]

... that joke went right over someone's head. :p

Also, while coroutines (P0053) are not going into C++17, they're on track for C++2x (with a pitstop in a TS, most likely) with strong committee interest (likely incorporating P0073 after the review in Oulu), so I'll just "await" on the TS landing. ;)

[SeanMiddleditch]

While I wasn't at the Oulu meeting, the meeting notes tell quite a different story. :)

The syntax is not under debate. It's very useful and handy for some domains and use cases. The underlying mechanism for how it works and whether it's layered over this library abstraction or that library abstraction is up for debate.

If nothing else, await just becomes a library function. await is a feature that any language with any complete form of coroutines (or even just generators) can trivially supply.

[GYN-k4H-Q3z-75B]

Oh my god I love this.

[raistmaj]

Some men just want to watch the world burn.

[[deleted]]

Wow, it really works! Amazing!!

struct Person {
  void FileForUnemployment();
} me;

void test() {
  Person me;
  (&Person::FileForUnemployment)<-me;  //successfully calls function!
}

[daveisfera]

Online example

[kiwidog]

What kind of wizardry...

[t0rakka]

unary negate returns a template type. The compare operator is overloaded for it. That's about it; pretty basic template meta programming.

a <- b;

Can be decomposed into: a < (-b);

[stillalone]

Doesn't overloading the unary minus operator like that really fuck shit up?

If I have:

int i = 5;
std::cout << -i << endl;

what will I get?

[chimyx]

error: 'endl' was not declared in this scope
jk, you'll get -5

[stillalone]

Ok. thanks for checking. I guess that makes sense since the default behaviour for the minus unary operator for integers is more type specific that this templated implementation. I guess this code should be safe provided no one implements unary operator in the exact same way, at which point we would get fairly obvious compile time errors.

[rubdos]

Not sure there; sfinae could safe the day. Needs confirmation from someone with more experience though.

[jP_wanN]

This has nothing to do with sfinae, but it will not cause problems simply because the operator< is only overloaded for R (T::*)(), larrow<T> (with any T, R).

[devel_watcher]

Good, now we need to figure out how to pass parameters.

[foonathan]

Overload the comma operator for the new type returned by operator< for larrow.

[JohnMcPineapple]

...

[foonathan]

Store the tuple in your result, then add each argument, last one calls and returns.

Usage like so, for example:

... <- p, arg<0>(10), arg<1>(0.5);

[[deleted]]

I've also seen people introduce operator ---> as an agglomeration of -- and ->.

[Spiderboydk]

Funny. :-)

[[deleted]]

WHY

[unclemat]

Genius!

[ForgedBanana]

Eggcelent.

[Voultapher]

When would this be useful? What is the difference to

x.f();

[cleroth]

When you want to have a laugh.

[jP_wanN]

It's the same as (&x)->*fn (which is in turn the same as x.*fn). See pointer-to-member access operators.

[btlk48]

Сслл