Mathieu Bouchard wrote:

> I often name ";" (and "\n") the sequence operator already, but this would
> be a second flavour:
> 
> A && B     run A and if true then run B
> A || B     run A and if false then run B
> A ; B      run A and then B no matter what

That is an interesting approach to viewing this.

> .. are three operators on expressions, but in A $ B, the B part obviously
> wouldn't be an expression, and even A would be restricted to being a
> method-call expression. I assume the binding will be rather low-precedence
> (mimicking Smalltalk's precedence could be a good idea). B is restricted
> to being a receiver-less method-call in which the receiver will be A's
> receiver instead of being the default self.

Though I'm still wondering how all this would look in an actual code sample.

Would this come close?

   obj $ first_call $ second_call

I think that would be quite hard to space out over multiple lines:

   obj $ first_call \
       $ second_call \
       $ third_call \
       $ fourth_call

And I'm wondering if calling setters and methods with complex arguments 
would also be possible with this syntax.

You know -- somehow I can't stop thinking of this as a parallelism 
operator...

> Any other ideas for the meaning of $ here? Any other characters? (I'd
> rather *not* use backslash)

@? Though then the order would somehow seem to be reversed...

> If people have violent allergic reactions to the use of "$" for *that*,
> then I'd suggest "&." instead, even though it's longer.
> 
> Another idea I've had is that, because prefix "." is not allowed in Ruby
> 1.8, it could later serve so that in "a.foo;.bar" the dot-prefix operator
> would make the method-call on the "syntactically previous" receiver, that
> is, a. How "previous" is defined may depend on precedence rules...

Somehow this looks a lot like an implicit call to $_. Perhaps we could 
rename $_ to a variable-like-construct 'it' (similar to self, false, 
true and nil).

But then again $_ is not only used for referring to the last method call 
result...