Re: MacRuby

On 2/28/08, Richard Kilmer <richinfoether.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>

Somehow I feel like I'm back in late 1981 or early 1982, 
when Brad
Cox and Tom Love at ITT, I at IBM, and probably others, had
read the
August 1981 issue of Byte magazine and were trying
independently to
graft Smalltalk onto C independently.  Brad, Tom and I later
became
friends when we met, but Objective-C certainly outlived
ClassC which
never really got any visibility outside of Big Blue.

More seriously, I tend to lean on the side of making things
like the
objective-c/ruby interface a little more visibility, since
I've
learned that transparency isn't always what it's cracked up
to be.
http://talklikeaduck.denha
ven2.com/articles/2007/11/17/cool-but-stupid-things-ive-done


-- 
Rick DeNatale

My blog on Ruby
http://talklikead
uck.denhaven2.com/

On Thu, Feb 28, 2008 at 6:19 PM, Rick DeNatale
<rick.denatalegmail.com> wrote:
> On 2/28/08, Richard Kilmer <richinfoether.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 ,
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,
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