transami wrote:

> On Wednesday 05 January 2005 07:41 pm, Florian Gro wrote:
> | Peter wrote:
> | > Funny thing: "1:10"methods calls String::Literal::methods("1:10") which
> | > happily returns all methods in String::Literal. That's the downside of
> | > using the unchanged suffix as method name.
> |
> | So maybe we should go back to the String.literal_methods style?
> 
> Perhaps
> 
>   class String
>     def @methods
>       # ...
>     end
>   end
> 
> If too much like instance variables, I like the '*'.

Could such specially named methods be invoked by anything other than
the Ruby parser?  Seeing as they just create objects from Strings,
I don't see way they should be special.

> 
> Another notion is to allow %methods to have a suffix notation.

This is an interesting idea.  But, I think it still would require 
quoting for simple cases.
2r would need to be written as %r{2} or, perhaps %{2}r
Correct?
Also, the %method approach seems to break existing scripts.
This approach should be backward compatible.

> Of course you can already do,
> 
>   "10:00".pm
> 
> so maybe I'm missing the point

Much of "the point" is, in fact, the elimination of punctuation.

("10:05".pm + 30.min).alarm    #alarm at 10:35PM
("10:05"pm + 30min).alarm      #shorter & closer to "natural" language
12oz + 4qt  #for those of us still stuck with these arcane units
"3/2".r + "7/5".r	#works, but not pretty.
3/2r + 7/5r		#more readable!

Most intrinsic objects have a special literal syntax recognized by 
Ruby's parser.  This proposal is to make it possible for user defined 
objects to participate in expressions more like intrinsic ones.  I think 
this is very much in the spirit of the language. Ruby already does a far 
better job than most OO languages in allowing user objects to behave 
like intrinsic ones.  Combined with user defined operators, the addition 
of user defined literals can make expressions involving user defined 
objects nearly as free of grammar artifacts as those involving Integers, 
Floats and Strings.

There is also at least a potential for optimization. The "string"suffix 
and NUMBERsuffix expressions may be evaluated once when they are parsed. 
  Ruby's late binding rules require that in {1000.times {"10".pm + 
srand}}, the "10".pm object is constructed 1000 times, because .pm is a 
method call.  In {1000.times {10pm + srand}}, 10pm need be constructed 
only once.  10pm is a constant, constructed when the program text is parsed.

But, you are correct in observing that it's all syntactic sugar.  We're 
not making Ruby any more "powerful" by adding this facility -- just more 
readable, and, perhaps, efficient.

- brent