From: Laurent Sansonetti <laurent.sansonetti@...>
Date: 2008-02-29T13:49:19+09:00
Subject: Re: [ANN] MacRuby

On Thu, Feb 28, 2008 at 6:19 PM, Rick DeNatale <rick.denatale@gmail.com> wrote:
> On 2/28/08, Richard Kilmer <rich@infoether.com> wrote:
>  >
>  >  On Feb 28, 2008, at 7:44 PM, Evan Phoenix wrote:
>
> >  > At one point, I had a small parser change that allowed this to be
>  >  > written as:
>  >  >
>  >  > O[duck foo: 1, bar: 2]
>  >  >
>  >  > The idea was that the rubinius compiler would detect this special
>  >  > form and emit the 'right thing'.
>  >  >
>  >  > I think a bit part of this is whether you expect users (and other
>  >  > code) to know they're calling out to Objective-C, or if you want
>  >  > tight integration. This is essential what matz says.
>  >  >
>  >  > By making special Objective-C syntax, then you can't pass in an
>  >  > Objective-C object and expect it to be duck-typed like normal ruby
>  >  > objects. But the trade off is that the syntax is less elegant. I
>  >  > think it's a trade off, and my 2 cents is you should opt for the
>  >  > more elegant syntax. This is because there are only a few tiny edge
>  >  > cases where the Objective-C selector matches the ruby selector,
>  >  > where you'd want to allow the ObjC object to be duck typed as
>  >  > something else.
>  >
>  > So in your view:
>  >
>  >         O[duck foo:1, bar:2]
>  >
>  > is elegant?  Elegant Ruby? no.  I agree to opt for the elegant syntax
>  >  and that's:
>  >
>  >         duck foo:1, bar:2
>  Or
>
>           duck foo: 1 bar: 2
>
>  which is even more elegant, since it's the same syntax as Smalltalk <G>
>

The problems with these syntaxes are that it's hard to parse them, and
that they can lead to ambiguities when wrongly used.

For example,

  duck.foo: x, with: y

could be written by mistake as

  duck.foo :x, with: y

which has a completely different meaning.

Also, when the parenthesizes are omitted, it may be hard to correctly
parse (assuming that you want to send the message to self)

  foo:x, with:y

That's why I think that the following is the best compromise so far,
between readability and reliability.

  foo x, with:y # or foo(x, with:y)

Laurent