Re: ANN: Free-form-operators patch

On Mon, 2004-10-11 at 16:16, Yukihiro Matsumoto wrote:
> Hi,
> 
> In message "Re: ANN: Free-form-operators patch"
>     on Tue, 12 Oct 2004 01:21:08 +0900, Markus <[e-mail]> writes:
> 
> |> * This patch makes difficult to add new operators in the language in
> |>   the future.  For example, I might feel like to add '->' behave as
> |>   lambda as in Perl6.
> 
> |     I don't think the patch would make it any harder to add operators
> |in the future--any more than user defined methods make it harder to add
> |methods.  In a way, it might make it easier, since they could be written
> |in ruby.
> 
> As long as it's a binary operator.  I'm thinking something more like
> syntax.  For example, Perl6's -> syntax works as "-> x, y {...}",
> which would, I think, conflict with any usage of user defined ->
> operator.

     Yes.  I seems to me that there are roughly three paths here:

      * move towards "standardized" operator syntax (a direction implied
        by my patch)

      * move towards "operators as syntax" (the perl lambda is a good
        example)

      * some middle path, perhaps adding some specific user definable
        operators (*smile* if you wish a can of worms, say that they can
        only use UTF-8 characters)

      * no change, the path of stillness

     I have no real preference between them; unlike the issue Proc.new()
automatically exploding single array argument (which would break a fair
amount of production code for me) this experimental patch is something I
started on because others seemed to be wanting it (or at least, wanting
things that it could give them).  Do you wish me to continue with it? 
Take it in some other direction?  Drop it?

     My goal here is to try to pay back some of what I owe ruby, so your
advise would be welcome.

-- Markus

P.S. With regard to perl's lambda, a year or so back I had suggested
generalizing the block syntax so that "{ |x,y| ... }" would produce a
lambda object.  In kicking it back and forth (unfortunately, I don't
recall with whom) we had worked out most of the obvious complications,
and decided that it was probably doable.  

The context was permitting user defined control structures but it seems
like it might resolve the specific problem and "look more like ruby"--I
mention it only because the idea may be useful.