[ruby-core:97036] [Ruby master Feature#16601] Let `nil.to_a` and `nil.to_h` return a fixed instance

Issue #16601 has been updated by byroot (Jean Boussier).


I'm not sure if `nil.to_a` and `nil.to_h` are actually frequent sources of allocations, but I agree with the general premise.

When profiling Ruby applications, it's frequent to see 30% of the time being spent in GC, which makes me think reducing useless allocations could lead to increased performance.

However as we've seen with [#16150] (freezing the return of `Symbol#to_s`), there are backward compatibility concerns.

So maybe the priority would be to implement [#16153] so that this kind of changes can go through a normal deprecation cycle.

----------------------------------------
Feature #16601: Let `nil.to_a` and `nil.to_h` return a fixed instance
https://bugs.ruby-lang.org/issues/16601#change-84129

* Author: sawa (Tsuyoshi Sawada)
* Status: Open
* Priority: Normal
----------------------------------------
Now, `nil.to_s` returns a fixed instance:

```ruby
nil.to_s.object_id # => 440
nil.to_s.object_id # => 440
nil.to_s.object_id # => 440
...
```

This is useful when we have some variable `foo` which may be either `nil` or a string, and we want to check its emptiness in a condition:

```ruby
if foo.to_s.empty?; ... end
```

By this feature, we do not (need to) create a new instance of an empty string each time we check `foo`, even when it happens to be `nil`.

There are similar situations with arrays and hashes. We may have variable `bar` which may be either `nil` or an array, or `baz` which may be either `nil` or a hash, and we want to check their emptiness in conditions as follows:

```ruby
if bar.to_a.empty?; ... end
```

```ruby
if baz.to_h.empty?; ... end
```

But unlike `nil.to_s`, the methods `nil.to_a` and `nil.to_h` create new instances of empty array or hash each time they are called:

```ruby
nil.to_a.object_id # => 540
nil.to_a.object_id # => 560
nil.to_a.object_id # => 580
...

nil.to_h.object_id # => 460
nil.to_h.object_id # => 480
nil.to_h.object_id # => 500
...
```

The fact that this is somewhat inefficient discourages the use of `foo.to_a` or `foo.to_h` in such use cases.

I request `nil.to_a` to `nil.to_h` to return a fixed empty instance.



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

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>