From: "adamdunson (Adam Dunson)" <adam@...>
Date: 2013-10-10T00:24:12+09:00
Subject: [ruby-core:57777] [ruby-trunk - Feature #8956] Allow hash members	delimited by \n inside of {}


Issue #8956 has been updated by adamdunson (Adam Dunson).


=begin

Hi sawa,

((*Another case where similar syntax might be relevant is `| |` inside a block. ... should go together with ... arguments in method definition*))

I agree. Arguments in method definitions have been on my to-do list ��� I haven't had much time lately to look at this, but good call on allowing newlines inside vertical bars in a block.

((*I also thought that maybe you can go one step further and allow any sequence of white characters as delimiters when the parentheses/braces/brackets/pipes are not omitted*))

I like the idea, but this one might be too ambitious. The problem that I see is that it introduces ambiguity when passing a method as an argument, e.g.,

 def foo(a, b = 0, c = 0)
   puts a + b + c
 end
 
 def bar(a = 0)
  a + 1
 end
 
 foo(bar 1 2)

In this instance, it is difficult to tell whether ((%foo%)) is being called with three arguments (((%bar%)), ((%1%)), and ((%2%))) or with two arguments (((%bar(1)%)) and ((%2%))).
=end

----------------------------------------
Feature #8956: Allow hash members delimited by \n inside of {}
https://bugs.ruby-lang.org/issues/8956#change-42383

Author: adamdunson (Adam Dunson)
Status: Open
Priority: Normal
Assignee: 
Category: core
Target version: 


=begin
Currently, hashes require members to be delimited by commas ((({,}))), even inside curly braces. E.g.,

  some_hash = {
    :foo => 'bar',
    :bar => 'foo',
    :baz => {
      :qux => 'quux',
      :corge => 'grault'
    }
  }

In my opinion, these commas add nothing of value to this particular example since, visually, the members are already delimited by a newline ((({\n}))). Additionally, missing a comma between members results in (({syntax error, unexpected tSYMBEG, expecting '}'})).

I propose we make these commas optional, such that the following syntax would be possible:

  some_hash = {
    :foo => 'bar'
    :bar => 'foo'
    :baz => {
      :qux => 'quux'
      :corge => 'grault'
    }
  }

This change would not affect existing hashes. Developers would be able to mix and match the old and new syntaxes as such:

  some_hash = {
    :foo => 'bar'
    :bar => 'foo'
    :baz => {
      :foo => 'bar' + 'baz'
      :bar => 'foo', :qux => 'quux'
      :corge => 'grault'
    }
  }

This change would also reduce the occurrence of syntax errors in cases where the developer temporarily replaces a value in the hash, e.g.,

  some_hash = {
    :this => 'that',
    :foo => 'not bar'#'bar',
    :those => 'the other'
  }

Finally, this change would only affect hashes inside curly braces (for hopefully obvious reasons).

I have attached a diff of my suggested changes along with a script to test a variety of use cases. I also have an open pull request on GitHub: ((<URL:https://github.com/ruby/ruby/pull/402>))

Please let me know if there's anything I've missed or that needs clarification.
=end


-- 
http://bugs.ruby-lang.org/