Issue #14336 has been updated by dsferreira (Daniel Ferreira).


Jeremy so we have some possible performance problems regarding frozen string literals that we should try to understand.

This is what I have on my side:

Code:

```ruby
#!/usr/bin/env ruby --enable-frozen-string-literal

require "benchmark/ips"

Benchmark.ips do |x| 
  x.report("literal fstring"){ a = 'a'; a == 'a'}
  x.report("symbol"){a = :a; a == :a} 
end
```

Results for ruby 2.3.0:

```
Warming up --------------------------------------
     literal fstring   263.644k i/100ms
              symbol   260.400k i/100ms
Calculating -------------------------------------
     literal fstring     10.969M ( 3.7%) i/s -     54.838M in   5.007198s
              symbol     10.809M ( 5.3%) i/s -     53.903M in   5.002792s
```

Results for ruby 2.5.0

```ruby
Warming up --------------------------------------
     literal fstring   301.226k i/100ms
              symbol   304.846k i/100ms
Calculating -------------------------------------
     literal fstring     10.701M ( 3.3%) i/s -     53.618M in   5.016530s
              symbol     11.121M ( 3.4%) i/s -     55.787M in   5.022618s
```

Why did frozen string literals outperformed symbols in ruby 2.3.0 and now that is not the case in 2.5.0?

----------------------------------------
Feature #14336: Create new method String#symbol? and deprecate Symbol class
https://bugs.ruby-lang.org/issues/14336#change-69448

* Author: dsferreira (Daniel Ferreira)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
From  the discussions on the three previous issues related to the String vs Symbol subject ([5964](https://bugs.ruby-lang.org/issues/5964), [7792](https://bugs.ruby-lang.org/issues/7792), [14277](https://bugs.ruby-lang.org/issues/14277)) there are some conclusions we can assume:
* Current String vs Symbol is not the ideal scenario. See: Matz and Koichi comments.
* Current philosophy is to use Symbols as identifiers and Strings when strings are needed.
* Current situation is that Symbols are being used in many code bases as strings except for strings that really need the String methods.
* Current situation is that we are designing APIs to handle both String and Symbol inputs forcing an overhead of API development.

I propose the deprecation of `Symbol` class and the introduction of `String#symbol?`.

```ruby
foo = :foo
foo.class # => String
foo.symbol? # => true
bar = "bar"
bar.class # => String
bar.symbol? # => false
```

For backwards compatibility transition path I propose:

```ruby
class Symbol
  def self.===(var)
    warn ("Warning message regarding deprecated class")
    if var.class == Symbol
      true
    elsif var.class == String && var.symbol?
      true
    else
      false
    end
  end
end

class String
  def is_a?(klass)
    case klass
    when String
      true
    when Symbol
      self.symbol?
    else
      false
    end
  end
end
```



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

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