Nobuyoshi Nakada wrote:
> If there were can be an arbitrary expression, it conflicts
> with the superclass notation.  Consider:
> 
>   class X < String
> 
> How do you see the above, X inherits String, or comparison
> between X and String?  We concluded that parentheses around the
> expression for a while ago.

So is it a parsing concern? Already there's extra logic in the 
left-hand-side to properly scope the constant name (::MyClass, 
MyModule::MyClass) so it seems like expanding that to do a method call 
would be ok too.

Also, I don't think it would even make sense to have a call on the LHS 
followed by the "extends" syntax...if it's making a call, you'd expect 
the class has already been created and already extends something.

class my_class() < String # superclass mismatch or parser error
class my_class() # parses ok, runtime error if it doesn't return a class
class my_class < String # same error as first example

LHS also already does support making some calls too, just not to finally 
get the class (only for scoping purposes as far as I can tell):

def foo; String; end
class foo::Blah; end
String::Blah.new # ok, class def uses foo call to scope Blah

It doesn't seem like we'd have to go far to just support method calls 
directly as the first token after "class".

- Charlie