[ruby-core:63338] [ruby-trunk - Feature #9980] [Open] Create HashWithIndiferentAccess using new syntax {a: 1}i

[ruby-core:63338] [ruby-trunk - Feature #9980] [Open] Create HashWithIndiferentAccess using new syntax {a: 1}i

[rr.rosas]

Issue #9980 has been reported by Rodrigo Rosenfeld Rosas.

----------------------------------------
Feature #9980: Create HashWithIndiferentAccess using new syntax {a: 1}i
https://bugs.ruby-lang.org/issues/9980

* Author: Rodrigo Rosenfeld Rosas
* Status: Open
* Priority: Normal
* Assignee: Yukihiro Matsumoto
* Category: syntax
* Target version: current: 2.2.0
----------------------------------------
This is related to feature #7797. For that feature I requested a regular hash ({}) to be treated as HWIA and the current hash implementation would be available as StrictHash.new since it's not as much needed as the common case of expecting a[:a] to be the same as a['a'].

Although I still prefer the proposal in #7797, I'd like to propose an alternative syntax for a new implementation of Hash that converts symbols to strings in keys (or keys to strings, it doesn't matter). This:

~~~
{my_key: 'my_value'}i
~~~

Should be equivalent to:

~~~
HashWithIndifferentAccess.new(my_key: 'my_value') # from ActiveSupport
~~~

It doesn't have to behave exactly like the implementation from ActiveSupport. I only really care about symbols and strings being treated the same way.

This is not as great as #7797 because it will only affect user's own code rather than hashes created by other libraries (unless they decide to adopt the new syntax, which could take quite a while to keep backward compatibility with old Ruby versions). But it would already make it way more pleasant to define new hashes with indifferent access.

Maybe it could act recursively during the hash creation, but I'm fine if you think it would be more confusing than helpful. To illustrate:

~~~
{a: {b: 1}}i
~~~

could mean the same as:

~~~
{a: {b: 1}i}i
~~~



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

[ruby-core:63339] [ruby-trunk - Feature #9980] Create HashWithIndiferentAccess using new syntax {a: 1}i

[rr.rosas]

Issue #9980 has been updated by Rodrigo Rosenfeld Rosas.

File feature-9980.pdf added

----------------------------------------
Feature #9980: Create HashWithIndiferentAccess using new syntax {a: 1}i
https://bugs.ruby-lang.org/issues/9980#change-47386

* Author: Rodrigo Rosenfeld Rosas
* Status: Open
* Priority: Normal
* Assignee: Yukihiro Matsumoto
* Category: syntax
* Target version: current: 2.2.0
----------------------------------------
This is related to feature #7797. For that feature I requested a regular hash ({}) to be treated as HWIA and the current hash implementation would be available as StrictHash.new since it's not as much needed as the common case of expecting a[:a] to be the same as a['a'].

Although I still prefer the proposal in #7797, I'd like to propose an alternative syntax for a new implementation of Hash that converts symbols to strings in keys (or keys to strings, it doesn't matter). This:

~~~
{my_key: 'my_value'}i
~~~

Should be equivalent to:

~~~
HashWithIndifferentAccess.new(my_key: 'my_value') # from ActiveSupport
~~~

It doesn't have to behave exactly like the implementation from ActiveSupport. I only really care about symbols and strings being treated the same way.

This is not as great as #7797 because it will only affect user's own code rather than hashes created by other libraries (unless they decide to adopt the new syntax, which could take quite a while to keep backward compatibility with old Ruby versions). But it would already make it way more pleasant to define new hashes with indifferent access.

Maybe it could act recursively during the hash creation, but I'm fine if you think it would be more confusing than helpful. To illustrate:

~~~
{a: {b: 1}}i
~~~

could mean the same as:

~~~
{a: {b: 1}i}i
~~~

---Files--------------------------------
feature-9980.pdf (24.8 KB)


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

[ruby-core:63424] [ruby-trunk - Feature #9980] Create HashWithIndiferentAccess using new syntax {a: 1}i

[naruse]

Issue #9980 has been updated by Yui NARUSE.


received, thanks!

----------------------------------------
Feature #9980: Create HashWithIndiferentAccess using new syntax {a: 1}i
https://bugs.ruby-lang.org/issues/9980#change-47467

* Author: Rodrigo Rosenfeld Rosas
* Status: Open
* Priority: Normal
* Assignee: Yukihiro Matsumoto
* Category: syntax
* Target version: current: 2.2.0
----------------------------------------
This is related to feature #7797. For that feature I requested a regular hash ({}) to be treated as HWIA and the current hash implementation would be available as StrictHash.new since it's not as much needed as the common case of expecting a[:a] to be the same as a['a'].

Although I still prefer the proposal in #7797, I'd like to propose an alternative syntax for a new implementation of Hash that converts symbols to strings in keys (or keys to strings, it doesn't matter). This:

~~~
{my_key: 'my_value'}i
~~~

Should be equivalent to:

~~~
HashWithIndifferentAccess.new(my_key: 'my_value') # from ActiveSupport
~~~

It doesn't have to behave exactly like the implementation from ActiveSupport. I only really care about symbols and strings being treated the same way.

This is not as great as #7797 because it will only affect user's own code rather than hashes created by other libraries (unless they decide to adopt the new syntax, which could take quite a while to keep backward compatibility with old Ruby versions). But it would already make it way more pleasant to define new hashes with indifferent access.

Maybe it could act recursively during the hash creation, but I'm fine if you think it would be more confusing than helpful. To illustrate:

~~~
{a: {b: 1}}i
~~~

could mean the same as:

~~~
{a: {b: 1}i}i
~~~

---Files--------------------------------
feature-9980.pdf (24.8 KB)


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

[ruby-core:63445] [ruby-trunk - Feature #9980] Create HashWithIndiferentAccess using new syntax {a: 1}i

[rr.rosas]

Issue #9980 has been updated by Rodrigo Rosenfeld Rosas.

File feature-9980.pdf added

Reattaching using Firefox

----------------------------------------
Feature #9980: Create HashWithIndiferentAccess using new syntax {a: 1}i
https://bugs.ruby-lang.org/issues/9980#change-47487

* Author: Rodrigo Rosenfeld Rosas
* Status: Open
* Priority: Normal
* Assignee: Yukihiro Matsumoto
* Category: syntax
* Target version: current: 2.2.0
----------------------------------------
This is related to feature #7797. For that feature I requested a regular hash ({}) to be treated as HWIA and the current hash implementation would be available as StrictHash.new since it's not as much needed as the common case of expecting a[:a] to be the same as a['a'].

Although I still prefer the proposal in #7797, I'd like to propose an alternative syntax for a new implementation of Hash that converts symbols to strings in keys (or keys to strings, it doesn't matter). This:

~~~
{my_key: 'my_value'}i
~~~

Should be equivalent to:

~~~
HashWithIndifferentAccess.new(my_key: 'my_value') # from ActiveSupport
~~~

It doesn't have to behave exactly like the implementation from ActiveSupport. I only really care about symbols and strings being treated the same way.

This is not as great as #7797 because it will only affect user's own code rather than hashes created by other libraries (unless they decide to adopt the new syntax, which could take quite a while to keep backward compatibility with old Ruby versions). But it would already make it way more pleasant to define new hashes with indifferent access.

Maybe it could act recursively during the hash creation, but I'm fine if you think it would be more confusing than helpful. To illustrate:

~~~
{a: {b: 1}}i
~~~

could mean the same as:

~~~
{a: {b: 1}i}i
~~~

---Files--------------------------------
feature-9980.pdf (24.8 KB)
feature-9980.pdf (24.8 KB)


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

[ruby-core:64026] [ruby-trunk - Feature #9980] Create HashWithIndiferentAccess using new syntax {a: 1}i

[naruse]

Issue #9980 has been updated by Yui NARUSE.

File deleted (feature-9980.pdf)

----------------------------------------
Feature #9980: Create HashWithIndiferentAccess using new syntax {a: 1}i
https://bugs.ruby-lang.org/issues/9980#change-48039

* Author: Rodrigo Rosenfeld Rosas
* Status: Open
* Priority: Normal
* Assignee: Yukihiro Matsumoto
* Category: syntax
* Target version: current: 2.2.0
----------------------------------------
This is related to feature #7797. For that feature I requested a regular hash ({}) to be treated as HWIA and the current hash implementation would be available as StrictHash.new since it's not as much needed as the common case of expecting a[:a] to be the same as a['a'].

Although I still prefer the proposal in #7797, I'd like to propose an alternative syntax for a new implementation of Hash that converts symbols to strings in keys (or keys to strings, it doesn't matter). This:

~~~
{my_key: 'my_value'}i
~~~

Should be equivalent to:

~~~
HashWithIndifferentAccess.new(my_key: 'my_value') # from ActiveSupport
~~~

It doesn't have to behave exactly like the implementation from ActiveSupport. I only really care about symbols and strings being treated the same way.

This is not as great as #7797 because it will only affect user's own code rather than hashes created by other libraries (unless they decide to adopt the new syntax, which could take quite a while to keep backward compatibility with old Ruby versions). But it would already make it way more pleasant to define new hashes with indifferent access.

Maybe it could act recursively during the hash creation, but I'm fine if you think it would be more confusing than helpful. To illustrate:

~~~
{a: {b: 1}}i
~~~

could mean the same as:

~~~
{a: {b: 1}i}i
~~~

---Files--------------------------------
feature-9980.pdf (24.8 KB)


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

[ruby-core:64028] [ruby-trunk - Feature #9980] [Rejected] Create HashWithIndiferentAccess using new syntax {a: 1}i

[matz]

Issue #9980 has been updated by Yukihiro Matsumoto.

Status changed from Open to Rejected

Suffix `i` is used for complex (imaginary) numbers. It's bit confusing.
Maybe what you want can be gained by shorter/nicer name for Hash#compare_by_identity.

Matz.


----------------------------------------
Feature #9980: Create HashWithIndiferentAccess using new syntax {a: 1}i
https://bugs.ruby-lang.org/issues/9980#change-48041

* Author: Rodrigo Rosenfeld Rosas
* Status: Rejected
* Priority: Normal
* Assignee: Yukihiro Matsumoto
* Category: syntax
* Target version: current: 2.2.0
----------------------------------------
This is related to feature #7797. For that feature I requested a regular hash ({}) to be treated as HWIA and the current hash implementation would be available as StrictHash.new since it's not as much needed as the common case of expecting a[:a] to be the same as a['a'].

Although I still prefer the proposal in #7797, I'd like to propose an alternative syntax for a new implementation of Hash that converts symbols to strings in keys (or keys to strings, it doesn't matter). This:

~~~
{my_key: 'my_value'}i
~~~

Should be equivalent to:

~~~
HashWithIndifferentAccess.new(my_key: 'my_value') # from ActiveSupport
~~~

It doesn't have to behave exactly like the implementation from ActiveSupport. I only really care about symbols and strings being treated the same way.

This is not as great as #7797 because it will only affect user's own code rather than hashes created by other libraries (unless they decide to adopt the new syntax, which could take quite a while to keep backward compatibility with old Ruby versions). But it would already make it way more pleasant to define new hashes with indifferent access.

Maybe it could act recursively during the hash creation, but I'm fine if you think it would be more confusing than helpful. To illustrate:

~~~
{a: {b: 1}}i
~~~

could mean the same as:

~~~
{a: {b: 1}i}i
~~~

---Files--------------------------------
feature-9980.pdf (24.8 KB)


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

[ruby-core:64097] [ruby-trunk - Feature #9980] Create HashWithIndiferentAccess using new syntax {a: 1}i

[rr.rosas]

Issue #9980 has been updated by Rodrigo Rosenfeld Rosas.


Was this rejected because the i suffix was already taken or because the idea of using suffixes would be confusing? Should I try another suffix in another ticket?

I don't think compare_by_identity does what I want. It seems to behave similar to ActiveSupport Hash#symbolize_keys which is different from Hash#with_indifferent_access which is what I really want.

I don't want to have to worry if I should call hash[:a] or hash['a']. Also compare_by_identity is a bad feature to me as it modifies the way the original hash works (it should be called compare_by_identity! in my opinion) and you can't undo its effect.

Maybe Ruby core could provide some utility to return a HWIA from a hash, like H(a: 1) meaning an equivalent of HWIA.new(a: 1).

----------------------------------------
Feature #9980: Create HashWithIndiferentAccess using new syntax {a: 1}i
https://bugs.ruby-lang.org/issues/9980#change-48109

* Author: Rodrigo Rosenfeld Rosas
* Status: Rejected
* Priority: Normal
* Assignee: Yukihiro Matsumoto
* Category: syntax
* Target version: current: 2.2.0
----------------------------------------
This is related to feature #7797. For that feature I requested a regular hash ({}) to be treated as HWIA and the current hash implementation would be available as StrictHash.new since it's not as much needed as the common case of expecting a[:a] to be the same as a['a'].

Although I still prefer the proposal in #7797, I'd like to propose an alternative syntax for a new implementation of Hash that converts symbols to strings in keys (or keys to strings, it doesn't matter). This:

~~~
{my_key: 'my_value'}i
~~~

Should be equivalent to:

~~~
HashWithIndifferentAccess.new(my_key: 'my_value') # from ActiveSupport
~~~

It doesn't have to behave exactly like the implementation from ActiveSupport. I only really care about symbols and strings being treated the same way.

This is not as great as #7797 because it will only affect user's own code rather than hashes created by other libraries (unless they decide to adopt the new syntax, which could take quite a while to keep backward compatibility with old Ruby versions). But it would already make it way more pleasant to define new hashes with indifferent access.

Maybe it could act recursively during the hash creation, but I'm fine if you think it would be more confusing than helpful. To illustrate:

~~~
{a: {b: 1}}i
~~~

could mean the same as:

~~~
{a: {b: 1}i}i
~~~

---Files--------------------------------
feature-9980.pdf (24.8 KB)


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