[ruby-core:32223] Re: Ruby 2.0 Wiki/Wish-list?

On 9/9/10 6:33 AM, "Martin J. D=C3=BCrst" wrote:
> On 2010/09/09 3:50, Kurt Stephens wrote:
>
>> ---------------------------------------------------
>>
>> I'd like to implement:
>>
>> x // y # and x //=3D y
>>
>> =3D>
>>
>> (tmp =3D x) !=3D nil ? tmp : y

Excuse my mistake, perhaps this should be:

   (tmp =3D x).nil? ? nil : y

Thus:

   x //=3D y

=3D>

   (tmp =3D x).nil? ? (x =3D y) : tmp

E.g.:

   x[:foo] //=3D 123

=3D>

   (tmp2 =3D (tmp1 =3D x)[:foo]).nil? ? (tmp1[:foo] =3D y) : tmp2

Works like &&=3D, except will not clobber false lhs.

This greatly simplifies setting non-nil defaults.

I believe this is a also a perl6 construct.  Since "//" and "//=3D" are=20
binary operators they should not conflict with "//" as the empty Regexp.
But they would certainly complicate the lexer/parser.

>
> One case that I remember having met frequently, and that seems to be
> related to this, is:
> In a method chain, apply methods successively, except if the receiver i=
s
> nil, in which case, just keep it as nil.
>
> As an example, I'd like to write something like:
>
> ((tmp1=3Da).nil? ? nil : tmp1.method1(args))
>
> as something like:
>
> a.unless_nil.method1(args)

See &&. below.

>
>> And
>>
>> x&&.y&&.z # and x//.y//.z
>>
>> =3D>
>>
>> (tmp =3D x) && (tmp =3D tmp.y) && tmp.z
>
> Shouldn't that be
> (tmp =3D x) && tmp.y && tmp.z ? That would make more sense to me. Also,=
 is
> there a way to express this as a binary operator?
>

   rcvr &&. selector

=3D>

   (tmp =3D rcvr) && tmp.selector

Consider:

   x&&.y&&.z

similar to

   x.y.z

but with false checks on each LHS expr.

> And what's the semantics of x//.y//.z ?
>

   rcvr //. selector

=3D>

   (tmp =3D rcvr).nil? ? nil : tmp.selector


Thus:

   x//.y//.z

is similar to:

   x.y.z

but with nil checks on each LHS expr.

This simplifies code like:

   if x && x.y && x.y.z
     ...
   end

Which, if #x, X#y or Y#z are expensive methods, is sometimes rewritten:

   if (tmp =3D x) && (tmp =3D tmp.y) && (tmp =3D tmp.z)
     ...
   end

This leads to a .=3D operator :)

   if (tmp =3D x) && (tmp .=3D y) && (tmp .=3D z)
     ...
   end

   lhs .=3D mcall(*margs)

=3D>

   lhs =3D lhs.mcall(*margs)

i.e:

   lhs &&=3D val

=3D>

   lhs =3D lhs && val

> Regards, Martin.
KAS