From: "sawa (Tsuyoshi Sawada)" <sawadatsuyoshi@...>
Date: 2013-10-02T07:31:19+09:00
Subject: [ruby-core:57567] [ruby-trunk - Feature #8956] Allow hash members	delimited by \n inside of {}


Issue #8956 has been updated by sawa (Tsuyoshi Sawada).


=begin
Another case where similar syntax might be relevant is `| |` inside a block. Whether you want to do this:

   {|
      foo
      bar
      baz
    | ....}

should go together with whether arguments in method definition can be written as:

    def foo(
      foo
      bar = some_complicated_expression_as_default_value
      baz = maybe_another_complicated_default_value
    )... end

The latter is useful if you want to put some complicated expression as default value. Usefulness of the former would depend on whether default value would be allowed for block variables.

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

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/