[ruby-core:65762] [ruby-trunk - Feature #8976] file-scope freeze_string directive

Issue #8976 has been updated by Eric Wong.


 [e-mail] wrote:
 > Recent Eric Wong's effort reminds me this issue.
 > 
 > I still think this issue is worth to consider.
 > 
 > Ruby 2.1 changed the semantics of "...".freeze to avoid string allocation.
 > It is not used extensively, I feel.
 
 Right, "...".freeze is too ugly IMHO.  Ruby should stay beautiful :)
 
 > File scope directive provides a way to use frozen string literals with
 > much fewer modification to programs.
 > 
 > Also, I think frozen string literals is a better programming style.
 > It needs dup call ("...".dup) for string literals to be modified.
 
 I also think needing to call "...".dup is ugly and will break much
 existing code[1].
 
 > It makes us to prevent unintentional modification and
 > we can distinguish string literals to be modified or not, more easily.
 
 My concern is optimizing Ruby for the typical script language users[2],
 not the (few) Rubyists who understand VM internals.
 
 I prefer we continue to improve Ruby, transparently:
 
 * 2.1 (past)     - { "str" => ... }, "str".freeze
 * 2.2 (done)     - h["str"] (= ...)
 * 2.2 (planned)  - .{gsub/sub/tr/tr_s}(["str"]|/../, "str"), ==, %,
                    many more core (cfunc) methods
 
 All of the above are transparent to existing code.
 
 > I would like that future Ruby (Ruby 3.0?) will interpret string
 > literals as frozen by default.
 > This issue can be considered as a migration path.
 > We can introduce file-scope directive now and change the default at
 > future when most programs uses frozen string literals.
 
 I am against this; especially as a default for 3.0[1].  File scope
 directives makes refactoring and reorganization of code more difficult:
 move a method to a new file and behavior changes.
 
 I hope we can implement more optimization transparently in the compiler.
 For example; we should be able to optimize more cases:
 
        def foo(a, b)
 	 a.gsub(/baz/, b)
        end
 
        foo(a, "lit") # no dup if `a' is a string
 
 I think we can also use use (internal) C-API changes to mark cfuncs as
 taking const args.  It would be useful for things like Hash#merge!, too;
 not just string literals.
 
 [1] - Even for Ruby 3.0; I strongly favor maintaining backwards
       compatibility as much as possible in Ruby-land.
       1.8 -> 1.9 was very painful for some users (including myself)

----------------------------------------
Feature #8976: file-scope freeze_string directive
https://bugs.ruby-lang.org/issues/8976#change-49495

* Author: Akira Tanaka
* Status: Open
* Priority: Normal
* Assignee: 
* Category: 
* Target version: current: 2.2.0
----------------------------------------
Yesterday, we had a face-to-face developer meeting.
https://bugs.ruby-lang.org/projects/ruby/wiki/DevelopersMeeting20131001Japan
Several committers attended.
matz didn't attended, though.  (This means this issue is not concluded.)

We believe we found a better way to freeze static string literals for
less GC pressure.
"static string literal" is a string literal without dynamic expression.

Currently, f-suffix, "..."f, is used to freeze a string literal to avoid
String object allocation.

There are several problems for f-suffix:

* The notation is ugly.
* Syntax error on Ruby 2.0.
  We cannot use the feature in version independent libraries.
  So, it is difficult to deploy.
* Need to modify for each string literal.
  This is cumbersome.

The new way we found is a file-scope directive as follows

  # freeze_string: true

The above comment at top of a file changes semantics of
static string literals in the file.
The static string literals will be frozen and always returns same object.
(The semantics of dynamic string literals is not changed.)

This way has following benefits:

* No ugly f-suffix.
* No syntax error on older Ruby.
* We need only a line for each file.

We can write version independent library using frozen static string literals as follows.

* Use the directive at top of the file: # freeze_string: true
  Older Ruby ignore this as a comment.
* Use "...".dup for strings to be modified.
  Older Ruby has small disadvantage: useless dup is called.

Note that the directive effects all static string literals regardless of
single quotes, double quotes, %q-string, %qq-string and here documents.
The reason that the directive is effective not only single quotes is
we want to use escape sequences such as \n in frozen string literals.

Also note that similar directive is already exist:

  % ruby -w -e '
  def m
    end
  '
  -e:3: warning: mismatched indentations at 'end' with 'def' at 2
  % ruby -w -e '# -*- warn_indent: false -*-
  def m
    end
  '

The directive, warn_indent: false, disables "mismatched indentations" warning.

nobu implemented this feature in the meeting.
Please attach the patch, nobu.




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