- ruby-core - ml.ruby-lang.org

[ruby-core:111107] [Ruby master Bug#18751] Regression on master for Method#== when comparing public with private method
by matz (Yukihiro Matsumoto) 01 Dec '22

01 Dec '22

Issue #18751 has been updated by matz (Yukihiro Matsumoto). This should be fixed by #18798 which is accepted. Matz. ---------------------------------------- Bug #18751: Regression on master for Method#== when comparing public with private method https://bugs.ruby-lang.org/issues/18751#change-100377 * Author: Eregon (Benoit Daloze) * Status: Closed * Priority: Normal * Assignee: Eregon (Benoit Daloze) * ruby -v: ruby 3.2.0dev (2022-04-23T02:59:20Z master e142bea799) [x86_64-linux] * Backport: 2.7: DONTNEED, 3.0: DONTNEED, 3.1: DONTNEED ---------------------------------------- This script repros: ```ruby class C class << self alias_method :n, :new private :new end end p C.method(:n) == C.method(:new) # => true puts p C.method(:n) == Class.method(:new) # => false p C.method(:n) == Class.method(:new).unbind.bind(C) # => true puts p C.method(:new) == Class.method(:new) # => false p C.method(:new) == Class.method(:new).unbind.bind(C) # => true, BUT false on master p C.method(:new) == Class.instance_method(:new).bind(C) # => true, BUT false on master p [C.method(:new), Class.instance_method(:new).bind(C)] # => [#<Method: #<Class:C>(Class)#new(*)>, #<Method: #<Class:C>(Class)#new(*)>] ``` So this prints the expected results on 2.7.5, 3.0.3, 3.1.1 but not on master, which seems a regression. Notably this breaks the pattern discussed in https://bugs.ruby-lang.org/issues/18729#note-5, and it means there is no way to find out if two methods share the same "definition/logic/def", which is a big limitation. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111106] [Ruby master Feature#18798] `UnboundMethod#==` with inherited classes
by matz (Yukihiro Matsumoto) 01 Dec '22

01 Dec '22

Issue #18798 has been updated by matz (Yukihiro Matsumoto). LGTM. Matz. ---------------------------------------- Feature #18798: `UnboundMethod#==` with inherited classes https://bugs.ruby-lang.org/issues/18798#change-100374 * Author: ko1 (Koichi Sasada) * Status: Open * Priority: Normal ---------------------------------------- Now `UnboundMethod` for a same method from a superclass and an inherited class are not `==`. ```ruby class C def foo = :C $mc = instance_method(:foo) end class D < C $md = instance_method(:foo) end p $mc == $md #=> false p $mc.owner #=> C p $mc.owner == $md.owner #=> true p $mc.source_location == $md.source_location #=> true p $mc.inspect #=> "#<UnboundMethod: C#foo() t.rb:3>" p $md.inspect #=> "#<UnboundMethod: D(C)#foo() t.rb:3>" ``` How about to make it `UnboundMethod#==` return true for this case? Rule: "return true if the UnboundMethod objects point to a same method definition" seems simple. FYI: On aliased unbound methods point to a same method are `==`. ```ruby class C def foo = :C alias bar foo $mfoo = instance_method(:foo) $mbar = instance_method(:bar) end p $mfoo, $mbar #=> #<UnboundMethod: C#foo() t.rb:2> #=> #<UnboundMethod: C#bar(foo)() t.rb:2> p $mfoo == $mbar #=> true ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111105] [Ruby master Bug#19047] DelegateClass displays "method redefined" warning when overriding methods
by matz (Yukihiro Matsumoto) 01 Dec '22

01 Dec '22

Issue #19047 has been updated by matz (Yukihiro Matsumoto). Sorry, but by this change, we missed the warnings from DelegateClass misuse. We will revert this change. Matz. ---------------------------------------- Bug #19047: DelegateClass displays "method redefined" warning when overriding methods https://bugs.ruby-lang.org/issues/19047#change-100373 * Author: jonathanhefner (Jonathan Hefner) * Status: Closed * Priority: Normal * ruby -v: ruby 3.1.2p20 * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- Perhaps this is not a bug, but it does seem unexpected. When creating a `DelegateClass` class without an intervening ancestor, overriding a method displays "method redefined" warning: ```ruby Base = Class.new do def foo "foo" end end Delegate1 = DelegateClass(Base) do def foo super + "1" end end # warning: method redefined; discarding old foo Delegate2 = Class.new(DelegateClass(Base)) do def foo super + "2" end end # no warning Delegate1.new(Base.new).foo # => "foo1" Delegate2.new(Base.new).foo # => "foo2" ``` One possible solution would be to evaluate the `DelegateClass` block in a separate module, and prepend that module to the returned class. Another possible solution would be to silence warnings around [when the block is evaluated](https://github.com/ruby/delegate/blob/df2283b8d8874446086b80355c…. I would be happy to submit a PR to https://github.com/ruby/delegate if this is something we want to address. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111104] [Ruby master Bug#19079] Modules included in a DelegateClass cannot override delegate methods
by matz (Yukihiro Matsumoto) 01 Dec '22

01 Dec '22

Issue #19079 has been updated by matz (Yukihiro Matsumoto). Status changed from Open to Rejected The `DelegateClass` defines an anonymous class and defines forwarding methods to the class. The reported (so-called) issue is a natural consequence of the above behavior. `include` add methods defined in a module **above** the current class, so forwarding methods have higher precedence. If you (re)define a method, it overwrites the forwarding method. My opinion is that your assumption is wrong, so we don't need to fix. If you think we need to implement your assumption, you need to persuade us with the real world use-case. Matz. ---------------------------------------- Bug #19079: Modules included in a DelegateClass cannot override delegate methods https://bugs.ruby-lang.org/issues/19079#change-100371 * Author: jonathanhefner (Jonathan Hefner) * Status: Rejected * Priority: Normal * ruby -v: ruby 3.1.2p20 * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- Because `DelegateClass` defines delegate methods on the class itself, those delegate methods come first in the method lookup chain. This prevents included modules from overriding delegate methods: ```ruby Base = Class.new do def foo "base" end end Helper = Module.new do def foo "helper" end end WithHelper = DelegateClass(Base) { include Helper } WithHelper.new(Base.new).foo # => "base" ``` One possible solution would be to define the delegate methods in a separate module. That way, other modules could come before it in the method lookup chain. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111103] [Ruby master Feature#19078] Introduce `Fiber#storage` for inheritable fiber-scoped variables.
by matz (Yukihiro Matsumoto) 01 Dec '22

01 Dec '22

Issue #19078 has been updated by matz (Yukihiro Matsumoto). This proposal contains 4 features: (1) fiber[key]/fiber[key]=val - accepted. (2) fiber.storage => hash - accepted (3) fiber.storage=hash - should be experimental (4) Fiber.new(...,storage: hash|true|false|nil) - accepted, but true/false should be experimental The feature (3) can be bigger side effect to clear third-party storage, so we need some experiment. The feature (4) with true/false are hard to read the intention (true to inherit with dup, false to inherit without dup), so we need experiment here as well. Matz. ---------------------------------------- Feature #19078: Introduce `Fiber#storage` for inheritable fiber-scoped variables. https://bugs.ruby-lang.org/issues/19078#change-100370 * Author: ioquatix (Samuel Williams) * Status: Open * Priority: Normal * Assignee: ioquatix (Samuel Williams) ---------------------------------------- Pull Request: https://github.com/ruby/ruby/pull/6612 This is an evolution of the previous ideas: - https://bugs.ruby-lang.org/issues/19058 - https://bugs.ruby-lang.org/issues/19062 This PR introduces fiber scoped variables, and is a solution for problems like <https://github.com/ioquatix/ioquatix/discussions/17>. The main interface is: ```ruby Fiber[key] = value Fiber[key] # => value ``` The variables are scoped (local to) a fiber and inherited into child fibers and threads. ```ruby Fiber[:request_id] = SecureRandom.hex(16) Fiber.new do p Fiber[:request_id] # prints the above request id end ``` The fiber scoped variables are stored and can be accessed: ```ruby Fiber.current.storage # => returns a Hash (copy) of the internal storage. Fiber.current.storage= # => assigns a Hash (copy) to the internal storage. ``` Fiber itself has one new keyword argument: ``` Fiber.new(..., storage: hash, false, undef, nil) ``` This can control how the fiber variables are setup in a child context. To minimise the performance overhead of some of the implementation choices, we are also simultaneously implementing <https://bugs.ruby-lang.org/issues/19077>. ## Examples ### Request loop ```ruby Thread.new do while request = queue.pop Fiber.new(storage: {id: SecureRandom.hex(16)}) do handle_request.call(request) end end end ``` OR ```ruby Thread.new do while request = queue.pop Fiber.current.storage = {id: SecureRandom.hex(16)} handle_request.call(request) end end ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111102] [Ruby master Feature#13721] [PATCH] net/imap: dedupe attr keys in Net::IMAP::FetchData
by shugo (Shugo Maeda) 01 Dec '22

01 Dec '22

Issue #13721 has been updated by shugo (Shugo Maeda). Status changed from Assigned to Rejected Rejected because [Feature #13725] was reverted and not fixed yet. ---------------------------------------- Feature #13721: [PATCH] net/imap: dedupe attr keys in Net::IMAP::FetchData https://bugs.ruby-lang.org/issues/13721#change-100369 * Author: normalperson (Eric Wong) * Status: Rejected * Priority: Normal * Assignee: normalperson (Eric Wong) ---------------------------------------- Since attr hash keys are frequently reused, it makes sense to deduplicate them up front. This saves one allocation per-attr, per-message. When running imap.fetch(1..-1, 'UID') on a mailbox with 30000 messages; this saves 30000 allocations. This relies on the String#-@ change in [Feature #13077] * net/imap: use frozen, deduplicated string in attr name (key) Trivial (1-byte change :), I may commit in a few days if no response. ---Files-------------------------------- 0001-net-imap-dedupe-attr-keys-in-Net-IMAP-FetchData.patch (1 KB) -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111054] [Ruby master Bug#19159] ObjectSpace segfaults
by matsuda (Akira Matsuda) 30 Nov '22

30 Nov '22

Issue #19159 has been reported by matsuda (Akira Matsuda). ---------------------------------------- Bug #19159: ObjectSpace segfaults https://bugs.ruby-lang.org/issues/19159 * Author: matsuda (Akira Matsuda) * Status: Open * Priority: Normal * ruby -v: ruby 3.2.0dev (2022-11-29T09:23:00Z master 67ae3e9738) +YJIT [arm64-darwin21] * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- ``` $ ruby -e 'p ObjectSpace.each_object.to_a' ``` segfaults on my M1MBP as follows: ``` $ ruby -e 'p ObjectSpace.each_object.to_a' -e:1: [BUG] Segmentation fault at 0x0000000000000000 ruby 3.2.0dev (2022-11-29T09:23:00Z master 67ae3e9738) +YJIT [arm64-darwin21] -- Crash Report log information -------------------------------------------- See Crash Report log file in one of the following locations: * ~/Library/Logs/DiagnosticReports * /Library/Logs/DiagnosticReports for more details. Don't forget to include the above Crash Report log file in bug reports. -- Control frame information ----------------------------------------------- c:0005 p:---- s:0017 e:000016 CFUNC :inspect c:0004 p:---- s:0014 e:000013 CFUNC :inspect c:0003 p:---- s:0011 e:000010 CFUNC :p c:0002 p:0009 s:0006 e:000005 EVAL -e:1 [FINISH] c:0001 p:0000 s:0003 E:0005a0 DUMMY [FINISH] -- Ruby level backtrace information ---------------------------------------- -e:1:in `<main>' -e:1:in `p' -e:1:in `inspect' -e:1:in `inspect' -- Machine register context ------------------------------------------------ x0: 0x0000000000000000 x1: 0x0000000000000004 x2: 0x0000000000000001 x3: 0x0000000104090e94 x4: 0x0000000000000275 x5: 0x0000000000000ad1 x6: 0x0000000000000020 x7: 0x000000016ef18a00 x18: 0x0000000000000000 x19: 0x0000000000000000 x20: 0x0000000000000001 x21: 0x0000000000000004 x22: 0x0000000104090e98 x23: 0x0000000000000001 x24: 0x0000000000000000 x25: 0x0000000000000001 x26: 0x0000000158127f00 x27: 0x00006000032ab4b0 x28: 0x0000000055550083 lr: 0x000000010108a058 fp: 0x000000016ef1a0f0 sp: 0x000000016ef1a0b0 -- C level backtrace information ------------------------------------------- ~/.rbenv/versions/3.2.0-dev/bin/ruby(rb_vm_bugreport+0x2410000000009ac) [0x24100010115a564] ~/.rbenv/versions/3.2.0-dev/bin/ruby(rb_bug_for_fatal_signal) [0x9b16000100f7fe68] ~/.rbenv/versions/3.2.0-dev/bin/ruby(sig_do_nothing) [0x646c0001010b9638] /usr/lib/system/libsystem_platform.dylib(_sigtramp+0x664c000000000038) [0x664c0001a77f34a4] [0x38] -- Other runtime information ----------------------------------------------- * Loaded script: -e * Loaded features: 0 enumerator.so 1 thread.rb 2 fiber.so 3 rational.so 4 complex.so 5 ruby2_keywords.rb 6 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/encdb.bundle 7 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/trans/transdb.bundle 8 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/rbconfig.rb 9 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/compatibility.rb 10 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/defaults.rb 11 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/deprecate.rb 12 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/errors.rb 13 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/unknown_command_spell_checker.rb 14 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/exceptions.rb 15 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/basic_specification.rb 16 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/stub_specification.rb 17 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/platform.rb 18 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/util/list.rb 19 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/version.rb 20 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/requirement.rb 21 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/specification.rb 22 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/util.rb 23 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/dependency.rb 24 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/core_ext/kernel_gem.rb 25 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/monitor.bundle 26 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/monitor.rb 27 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/core_ext/kernel_require.rb 28 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/core_ext/kernel_warn.rb 29 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems.rb 30 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/rubygems/path_support.rb 31 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/error_highlight/version.rb 32 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/error_highlight/base.rb 33 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/error_highlight/formatter.rb 34 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/error_highlight/core_ext.rb 35 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/error_highlight.rb 36 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/version.rb 37 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/core_ext/name_error.rb 38 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/levenshtein.rb 39 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/jaro_winkler.rb 40 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checker.rb 41 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb 42 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb 43 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checkers/name_error_checkers.rb 44 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checkers/method_name_checker.rb 45 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checkers/key_error_checker.rb 46 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checkers/null_checker.rb 47 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/tree_spell_checker.rb 48 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checkers/require_path_checker.rb 49 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/spell_checkers/pattern_key_name_checker.rb 50 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean/formatter.rb 51 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/did_you_mean.rb 52 ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/syntax_suggest/core_ext.rb * Process memory map: 100ee4000-101390000 r-x ~/.rbenv/versions/3.2.0-dev/bin/ruby 101390000-1013ac000 r-- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1013ac000-1013b0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1013b0000-1013c0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1013c0000-1015a8000 r-- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1015a8000-1016a8000 r-- /usr/lib/dyld 1016a8000-1016b0000 rw- /usr/lib/dyld 1016b0000-1016b4000 r-- /usr/lib/dyld 1016b4000-1016b8000 r-- /usr/lib/dyld 1016b8000-1016bc000 rw- /usr/lib/dyld 1016bc000-1016c0000 --- /usr/lib/dyld 1016c0000-1016c8000 rw- /usr/lib/dyld 1016c8000-1016cc000 --- /usr/lib/dyld 1016cc000-1016d0000 --- /usr/lib/dyld 1016d0000-1016d8000 rw- /usr/lib/dyld 1016d8000-1016dc000 --- /usr/lib/dyld 1016dc000-1016e0000 --- /usr/lib/dyld 1016e0000-1016e8000 rw- /usr/lib/dyld 1016e8000-1016ec000 --- /usr/lib/dyld 1016ec000-1016f0000 r-- /usr/lib/dyld 1016f0000-1016f4000 r-- /usr/lib/dyld 1016f4000-1016f8000 rw- /usr/lib/dyld 1016f8000-1016fc000 r-- /usr/lib/dyld 1016fc000-10173c000 rw- /usr/lib/dyld 101740000-101750000 rw- /usr/lib/dyld 10175c000-1017bc000 r-x /usr/lib/dyld 1017bc000-1017d4000 r-- /usr/lib/dyld 1017d4000-1017d8000 rw- /usr/lib/dyld 1017d8000-101810000 r-- /usr/lib/dyld 101810000-101868000 r-x /opt/homebrew/Cellar/gmp/6.2.1_1/lib/libgmp.10.dylib 101868000-10186c000 r-- /opt/homebrew/Cellar/gmp/6.2.1_1/lib/libgmp.10.dylib 10186c000-101870000 rw- /opt/homebrew/Cellar/gmp/6.2.1_1/lib/libgmp.10.dylib 101870000-101880000 r-- /opt/homebrew/Cellar/gmp/6.2.1_1/lib/libgmp.10.dylib 101880000-101884000 r-x ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/encdb.bundle 101884000-101888000 r-- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/encdb.bundle 101888000-10188c000 r-- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/encdb.bundle 101890000-1018a0000 rw- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/trans/transdb.bundle 1018a0000-1018a4000 r-x ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/trans/transdb.bundle 1018a4000-1018a8000 r-- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/trans/transdb.bundle 1018a8000-1018ac000 r-- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/enc/trans/transdb.bundle 1018b0000-1018c0000 rw- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/monitor.bundle 1018c0000-1018c4000 r-x ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/monitor.bundle 1018c4000-1018c8000 r-- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/monitor.bundle 1018c8000-1018cc000 rw- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/monitor.bundle 1018cc000-1018d0000 r-- ~/.rbenv/versions/3.2.0-dev/lib/ruby/3.2.0+3/arm64-darwin21/monitor.bundle 1018d0000-1018e0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1018f0000-101900000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 101910000-101920000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 101920000-102920000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102930000-102940000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102950000-102960000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102970000-102980000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102980000-102984000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102984000-102a28000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102a28000-102a2c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102a2c000-102ad0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102ad0000-102ad4000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102ad4000-102b78000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102b78000-102b7c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102b7c000-102c20000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102c20000-102c24000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102c24000-102cc8000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102cc8000-102ccc000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102ccc000-102d70000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102d70000-102d74000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102d74000-102e18000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102e18000-102e1c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102e1c000-102ec0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102ec0000-102ec4000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102ec4000-102f68000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102f68000-102f6c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 102f6c000-103010000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103010000-103014000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103014000-1030b8000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1030b8000-1030bc000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1030bc000-103160000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103160000-103164000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103164000-103208000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103208000-10320c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10320c000-1032b0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1032b0000-1032b4000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1032b4000-103358000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103358000-10335c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10335c000-103400000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103400000-103404000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103404000-1034a8000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1034a8000-1034ac000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1034ac000-103550000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103550000-103554000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103554000-1035f8000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1035f8000-1035fc000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1035fc000-1036a0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1036a0000-1036a4000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1036a4000-103748000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103748000-10374c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10374c000-1037f0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1037f0000-1037f4000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1037f4000-103898000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103898000-10389c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10389c000-103940000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103940000-103944000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103944000-1039e8000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1039e8000-1039ec000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1039ec000-103a90000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103a90000-103a94000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103a94000-103b38000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103b38000-103b3c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103b3c000-103be0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103be0000-103be4000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103be4000-103c88000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103c88000-103c8c000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103c8c000-103d30000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103d30000-103d34000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103d34000-103dd8000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103dd8000-103ddc000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103ddc000-103e80000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103e90000-103ea0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103eb0000-103ec0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103ed0000-103ee0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103ef0000-103f00000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103f10000-103f20000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103f30000-103f40000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103f50000-103f60000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103f70000-103f80000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103f90000-103fa0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103fb0000-103fc0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103fd0000-103fe0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 103ff0000-104000000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 104010000-104020000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 104030000-104040000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 104050000-104060000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 104070000-104080000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 104090000-1040a0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1040b0000-1040c0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1040d0000-1040e0000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 1040e0000-1040e4000 r-x ~/.rbenv/versions/3.2.0-dev/bin/ruby 1040e4000-1040e8000 r-x ~/.rbenv/versions/3.2.0-dev/bin/ruby 1040e8000-10c0e0000 --- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10c0f0000-10c100000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10c110000-10c120000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10c130000-10c140000 rw- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10c140000-10c7f4000 r-- ~/.rbenv/versions/3.2.0-dev/bin/ruby 10c7f4000-10cea8000 r-- ~/.rbenv/versions/3.2.0-dev/bin/ruby 138000000-138800000 rw- 138800000-139000000 rw- 139000000-139800000 rw- 139800000-13a000000 rw- 13a000000-13a800000 rw- 13a800000-13b000000 rw- 13b000000-13b800000 rw- 13b800000-13c000000 rw- 13c000000-13c800000 rw- 13c800000-13d000000 rw- 13d000000-13d800000 rw- 13d800000-13e000000 rw- 13e000000-13e800000 rw- 13e800000-13f000000 rw- 13f000000-13f800000 rw- 13f800000-140000000 rw- 146e00000-146f00000 rw- 146f00000-147000000 rw- 147000000-147800000 rw- 147800000-148000000 rw- 148000000-148800000 rw- 148800000-149000000 rw- 149000000-149800000 rw- 149800000-14a000000 rw- 14a000000-14a800000 rw- 14a800000-14b000000 rw- 14b000000-14b800000 rw- 14b800000-14c000000 rw- 14c000000-14c800000 rw- 14c800000-14d000000 rw- 14d000000-14d800000 rw- 14d800000-14e000000 rw- 14e000000-14e800000 rw- 14e800000-14f000000 rw- 14f000000-14f800000 rw- 14f800000-150000000 rw- 156e00000-156f00000 rw- 156f00000-157000000 rw- 157000000-157800000 rw- 157800000-157804000 rw- 158000000-158800000 rw- 158800000-159000000 rw- 159000000-159800000 rw- 159800000-15a000000 rw- 15a000000-15a800000 rw- 15a800000-15b000000 rw- 15b000000-15b800000 rw- 15b800000-15c000000 rw- 15c000000-15c800000 rw- 15c800000-15d000000 rw- 15d000000-15d800000 rw- 15d800000-15e000000 rw- 15e000000-15e800000 rw- 15e800000-15f000000 rw- 15f000000-15f800000 rw- 15f800000-160000000 rw- 160000000-162000000 rw- 162000000-162800000 rw- 16af1c000-16e720000 --- 16e720000-16ef1c000 rw- 16ef1c000-16ef20000 --- 16ef20000-16efa8000 rw- 180000000-1fc000000 r-- 1fc000000-1fd9d8000 r-- 1fd9d8000-1fd9fc000 rw- 1fd9fc000-1fe000000 rw- 1fe000000-200000000 r-- 200000000-2001e8000 r-- 2001e8000-2018dc000 rw- 2018dc000-204c64000 r-- 204c64000-206000000 r-- 206000000-236000000 r-- 236000000-236a10000 r-- 236a10000-2377f4000 rw- 2377f4000-238ac0000 r-- 238ac0000-23a000000 r-- 23a000000-280000000 r-- fc0000000-1000000000 --- 1000000000-7000000000 --- 600000000000-600008000000 rw- 600008000000-600010000000 rw- 600010000000-600018000000 rw- 600018000000-600020000000 rw- [IMPORTANT] Don't forget to include the Crash Report log file under DiagnosticReports directory in bug reports. ``` -- https://bugs.ruby-lang.org/

4 5

[ruby-core:111098] [Ruby master Feature#19000] Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object]
by RubyBugs (A Nonymous) 30 Nov '22

30 Nov '22

Issue #19000 has been updated by RubyBugs (A Nonymous). For comparison, you can plug in the following example code for a faster implementation of `#with` and it should work the same: ```ruby Point = Data.define(:x, :y) do # Example only, too slow. Real implementation should eliminate allocations. # def with(**args) # raise ArgumentError unless args.keys.all? { |k| members.include? k } # self.class.new(**(to_h.merge(args))) # end # A trick to avoid `nil` for defaults so that `nil` can be valid DEFAULT = class.new.new.freeze # An example of a faster implementation that could inspire auto-generation def with(x: DEFAULT, y: DEFAULT) self.class.new( x: x.equal?(DEFAULT) ? self.x : x), y: y.equal?(DEFAULT) ? self.y : y), ) end end ``` ---------------------------------------- Feature #19000: Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object] https://bugs.ruby-lang.org/issues/19000#change-100364 * Author: RubyBugs (A Nonymous) * Status: Open * Priority: Normal ---------------------------------------- *As requested: extracted a follow-up to #16122 Data: simple immutable value object from [this comment](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/109815)* # Proposal: Add a "Copy with changes" method to Data Assume the proposed `Data.define` exists. Seeing examples from the [[Values gem]](https://github.com/ms-ati/Values): ```ruby # A new class Point = Data.def(:x, :y) # An immutable instance Origin = Point.with(x: 0, y: 0) # Q: How do we make copies that change 1 or more values? right = Origin.with(x: 1.0) up = Origin.with(y: 1.0) up_and_right = right.with(y: up.y) # In loops movements = [ { x: +0.5 }, { x: +0.5 }, { y: -1.0 }, { x: +0.5 }, ] # position = Point(x: 1.5, y: -1.0) position = movements.inject(Origin) { |p, move| p.with(**move) } ``` ## Proposed detail: Call this method: `#with` ```ruby Money = Data.define(:amount, :currency) account = Money.new(amount: 100, currency: 'USD') transactions = [+10, -5, +15] account = transactions.inject(account) { |a, t| a.with(amount: a.amount + t) } #=> Money(amount: 120, currency: "USD") ``` ## Why add this "Copy with changes" method to the Data simple immutable value class? Called on an instance, it returns a new instance with only the provided parameters changed. This API affordance is now **widely adopted across many languages** for its usefulness. Why is it so useful? Because copying immutable value object instances, with 1 or more discrete changes to specific fields, is the proper and ubiquitous pattern that takes the place of mutation when working with immutable value objects. **Other languages** C# Records: “immutable record structs — Non-destructive mutation” — is called `with { ... }` https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-t… Scala Case Classes — is called `#copy` https://docs.scala-lang.org/tour/case-classes.html Java 14+ Records — Brian Goetz at Oracle is working on adding a with copy constructor inspired by C# above as we speak, likely to be called `#with` https://mail.openjdk.org/pipermail/amber-spec-experts/2022-June/003461.html Rust “Struct Update Syntax” via `..` syntax in constructor https://doc.rust-lang.org/book/ch05-01-defining-structs.html#creating-insta… ## Alternatives Without a copy-with-changes method, one must construct entirely new instances using the constructor. This can either be (a) fully spelled out as boilerplate code, or (b) use a symmetrical `#to_h` to feed the keyword-args constructor. **(a) Boilerplate using constructor** ```ruby Point = Data.define(:x, :y, :z) Origin = Point.new(x: 0.0, y: 0.0, z: 0.0) change = { z: -1.5 } # Have to use full constructor -- does this even work? point = Point.new(x: Origin.x, y: Origin.y, **change) ``` **(b) Using a separately proposed `#to_h` method and constructor symmetry** ```ruby Point = Data.define(:x, :y, :z) Origin = Point.new(x: 0.0, y: 0.0, z: 0.0) change = { z: -1.5 } # Have to use full constructor -- does this even work? point = Point.new(**(Origin.to_h.merge(change))) ``` Notice that the above are not ergonomic -- leading so many of our peer language communities to adopt the `#with` method to copy an instance with discrete changes. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111097] [Ruby master Feature#19000] Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object]
by RubyBugs (A Nonymous) 30 Nov '22

30 Nov '22

Issue #19000 has been updated by RubyBugs (A Nonymous). mame (Yusuke Endoh) wrote in #note-17: > @RubyBugs Please check my comment https://bugs.ruby-lang.org/issues/19000#note-13 . A wrong motivation example raises the suspicion that this API is actually confusing to users. Quite right @mame, thank you for catching that! I provided two examples. The first example is intended to use the previous values in creating the next values, and that part was broken. How is this? ```ruby ## # Example of proposed Data#with # # To try this out: # # ruby-install ruby-3.2.0-preview3 # ## Point = Data.define(:x, :y) do # Example only, too slow. Real implementation should eliminate allocations. def with(**args) raise ArgumentError unless args.keys.all? { |k| members.include? k } self.class.new(**(to_h.merge(args))) end end Origin = Point.new(x: 0, y: 0) # Q: How do we make copies that change 1 or more values? right = Origin.with(x: 1.0) up = Origin.with(y: 1.0) up_and_right = right.with(y: up.y) begin Origin.with(x: 1, z: 0) rescue ArgumentError puts "#with(z: 0) raised ArgumentError as expected" end # In loops movements = [ [ :x, +0.5 ], [ :x, +0.5 ], [ :y, -1.0 ], [ :x, +0.5 ], ] position = movements.inject(Origin) do |p, (field, delta)| p.with(field => p.to_h[field] + delta) end # position = Point(x: 1.5, y: -1.0) ``` ---------------------------------------- Feature #19000: Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object] https://bugs.ruby-lang.org/issues/19000#change-100363 * Author: RubyBugs (A Nonymous) * Status: Open * Priority: Normal ---------------------------------------- *As requested: extracted a follow-up to #16122 Data: simple immutable value object from [this comment](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/109815)* # Proposal: Add a "Copy with changes" method to Data Assume the proposed `Data.define` exists. Seeing examples from the [[Values gem]](https://github.com/ms-ati/Values): ```ruby # A new class Point = Data.def(:x, :y) # An immutable instance Origin = Point.with(x: 0, y: 0) # Q: How do we make copies that change 1 or more values? right = Origin.with(x: 1.0) up = Origin.with(y: 1.0) up_and_right = right.with(y: up.y) # In loops movements = [ { x: +0.5 }, { x: +0.5 }, { y: -1.0 }, { x: +0.5 }, ] # position = Point(x: 1.5, y: -1.0) position = movements.inject(Origin) { |p, move| p.with(**move) } ``` ## Proposed detail: Call this method: `#with` ```ruby Money = Data.define(:amount, :currency) account = Money.new(amount: 100, currency: 'USD') transactions = [+10, -5, +15] account = transactions.inject(account) { |a, t| a.with(amount: a.amount + t) } #=> Money(amount: 120, currency: "USD") ``` ## Why add this "Copy with changes" method to the Data simple immutable value class? Called on an instance, it returns a new instance with only the provided parameters changed. This API affordance is now **widely adopted across many languages** for its usefulness. Why is it so useful? Because copying immutable value object instances, with 1 or more discrete changes to specific fields, is the proper and ubiquitous pattern that takes the place of mutation when working with immutable value objects. **Other languages** C# Records: “immutable record structs — Non-destructive mutation” — is called `with { ... }` https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-t… Scala Case Classes — is called `#copy` https://docs.scala-lang.org/tour/case-classes.html Java 14+ Records — Brian Goetz at Oracle is working on adding a with copy constructor inspired by C# above as we speak, likely to be called `#with` https://mail.openjdk.org/pipermail/amber-spec-experts/2022-June/003461.html Rust “Struct Update Syntax” via `..` syntax in constructor https://doc.rust-lang.org/book/ch05-01-defining-structs.html#creating-insta… ## Alternatives Without a copy-with-changes method, one must construct entirely new instances using the constructor. This can either be (a) fully spelled out as boilerplate code, or (b) use a symmetrical `#to_h` to feed the keyword-args constructor. **(a) Boilerplate using constructor** ```ruby Point = Data.define(:x, :y, :z) Origin = Point.new(x: 0.0, y: 0.0, z: 0.0) change = { z: -1.5 } # Have to use full constructor -- does this even work? point = Point.new(x: Origin.x, y: Origin.y, **change) ``` **(b) Using a separately proposed `#to_h` method and constructor symmetry** ```ruby Point = Data.define(:x, :y, :z) Origin = Point.new(x: 0.0, y: 0.0, z: 0.0) change = { z: -1.5 } # Have to use full constructor -- does this even work? point = Point.new(**(Origin.to_h.merge(change))) ``` Notice that the above are not ergonomic -- leading so many of our peer language communities to adopt the `#with` method to copy an instance with discrete changes. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111095] [Ruby master Bug#18899] Inconsistent argument handling in IO#set_encoding
by Dan0042 (Daniel DeLorme) 30 Nov '22

30 Nov '22

Issue #18899 has been updated by Dan0042 (Daniel DeLorme). Naively, I would have expected "binary:utf-8" to take arbitrary input and force the encoding to UTF-8, and "utf-8:utf-8" to read and validate the input as UTF-8. Neither does what I expected. `¯\_(ツ)_/¯` ---------------------------------------- Bug #18899: Inconsistent argument handling in IO#set_encoding https://bugs.ruby-lang.org/issues/18899#change-100360 * Author: javanthropus (Jeremy Bopp) * Status: Open * Priority: Normal * ruby -v: ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [x86_64-linux] * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- `IO#set_encoding` behaves differently when processing a single String argument than it does when processing 2 arguments (whether Strings or Encodings) in the case where the external encoding is being set to binary and the internal encoding is being set to any other encoding. This script demonstrates the resulting values of the external and internal encodings for an IO instance given different ways to equivalently call `#set_encoding`: ```ruby #!/usr/bin/env ruby def show(io, args) printf( "args: %-50s external encoding: %-25s internal encoding: %-25s\n", args.inspect, io.external_encoding.inspect, io.internal_encoding.inspect ) end File.open('/dev/null') do |f| args = ['binary:utf-8'] f.set_encoding(*args) show(f, args) args = ['binary', 'utf-8'] f.set_encoding(*args) show(f, args) args = [Encoding.find('binary'), Encoding.find('utf-8')] f.set_encoding(*args) show(f, args) end ``` This behavior is the same from Ruby 2.7.0 to 3.1.2. -- https://bugs.ruby-lang.org/

1 0