Ruby-dev summary 17541-17608


(Minero Aoki) #1

Hi all,
This is a summary of ruby-dev ML in these days.

ruby-dev summary 17541-17608 (2002-06-22 … 2002-06-27)

[ruby-dev:17421] broken string when unterminated “#{”.

– From last article –
In current ruby, “#{“abc”}” is parsed as ‘“abc”’, not
’"#{" abc “}”’. Is this behavior smart or bad?
Tanaka Akira claimed that the notation of string
became a kind of ‘control structure’ and it is better that
we can write Ruby’s code in #{} without any escaping.
Matz agreed his opinion.

– This week –
Nobuyoshi Nakada has implemented “control structure #{…} block”.
But at the same time it breaks backward compatibility.
For example:

"...#{\"string\"}..."             # escape causes a syntax error.

"...#{some code  # comment}..."   # comment shadows closing quote;
                                  # causes a syntax error.

We must choose either powerful new function or backward
compatibility.

[to be continued]

[ruby-dev:17548] Ruby grammer

TANAKA Akira has suggested clarifying the syntax of Ruby.
The first topics are:
* omission of method call parentheses
e.g. print(“hello”) -> print “hello”
* precedence of blocks

Principles noted by matz:

* method-calls without parentheses cannot be nested (?)
    # not acceptable (?)
    method method method var

* do...end block associates with the most-left method call.
      m m()  do .... end
   -> m(m()) do .... end

      m ident  do .... end
   -> m(ident) do .... end   # `ident' is var_ref (lvar or method)

* {...} block associates with the most-right identifier.
      m m() { .... }
   -> m(m() { .... }))

      m ident { .... }
   -> m(ident() { .... }))  # `ident' becomes method call.

* Blocks can be chained.
   # acceptable
   m {....}.m {....}.m {....}
   m do....end.m do....end.m do....end

* Blocks cannot be nested.
   # not acceptable
   m {....} {....}
   m {....} do....end

[ruby-dev:17594] %w(… #{…} …)

Nobuyoshi Nakada has suggested a new literal-embedded expression
like this:

%W(word word str#{....} word)

Example:

var = 1
%W( word word #{var}str word )  # ['word','word','1str','word']

This idea is accepted.