Ruby master - Feature #16986: Anonymous Struct literal

First, I like the idea, so +1 for the idea. It also reminds me of
a more "prototypic-based approach" in general with structs, so if
the syntax could be made simpler to type, that seems to be a
possible improvement. And it fits into other "shortcut" variants,
such as %w()%I() and so forth. I make use of %w() and so forth
a LOT - it really helps when you have to create longer arrays;
we can avoid all the middle "','" parts.

What I dislike a bit about the suggestion here is the proposed
syntax. There are two aspects as to why that is the case for me:

(1) While I do sometimes use $ variables (in particular the regex
variants $1$2 are so convenient to use), sometimes I use $stdin
as well, but I don't quite like global variables in general. In
particular remembering $:$?$_ (if these even exist) is a bit
tedious. So most of the time when we can avoid $, I think this
is better than having to use $. But this is just one part.

(2) The other, perhaps slightly more problematic thing, is that
we would introduce a new variant of how people have to
understand $ variables.

Specifically this variant:

${a: 1,b: 2}

May look like regular variable substitution such as:

cat='Tom'puts"#{cat} is hunting Jerry."

Or, if people use global variables:

$cat='Tom'puts"#{$cat} is hunting Jerry."puts"#$cat is hunting Jerry."# ok perhaps not quite as much, since we can omit {} in that case.

Possibly the {} may have ruby user associate this with a regular
substitution.

The other aspect is that this would be the first global variable
use that combines {} upon "definition" time. We used to have
something like this:

$abc='def'

That feels a bit different to:

abc=${a: 1,b: 2}

Hmm.

Matz said he thought about {|a: 1, b: 2 |} syntax.

Do you mean without '$' there? If so then I think the syntax by
matz is better. Though people could assume it is a block. :)

However had, having said that, I do not have a good alternative
suggestion; and even then I think the feature may quite useful.

Perhaps:

structa: 1,b: 2

Would be somewhat short too.

Implying:

struct{a: 1,b: 2}

Though, admittedly the struct variant is still longer to type than
the $ suggestion here. While I don't quite like the $, it is arguably
short to type. And I suppose one requirement for this proposal is
that it should be shorter than:

Struct.new(:a,:b).new(1,2)

Even if made shorter, like:

Struct.new(a: 1,b: 2)

Admittedly the $ is shortest:

${a: 1,b: 2}

matz' variant:

foobar={|a: 1,b: 2|}foobar={|a: 1,b: 2|}foobar=${|a: 1,b: 2|}

(I was not sure which variant was the one; I assume matz' variant is
actually without the $, so perhaps the second variant.)

If we name the anonymous class, the same member literals share the
name.

s1=${a:1}s2=${a:2}

Hmmmmm. The matz' variant would then be like this?

s1={|a: 1|}

To be honest, even if that is longer, I think it is better than the
variant with $. I am not sure if I am the only one disliking the $
there but I think it would be better to not have to use $, even
if the second variant is longer. But as said, I think the idea
itself is fine.