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

[ruby-core:111556] [Ruby master Bug#19291] Ripper's on_parse_error token has wrong content
by tompng (tomoya ishida) 02 Jan '23

02 Jan '23

Issue #19291 has been reported by tompng (tomoya ishida). ---------------------------------------- Bug #19291: Ripper's on_parse_error token has wrong content https://bugs.ruby-lang.org/issues/19291 * Author: tompng (tomoya ishida) * Status: Open * Priority: Normal * ruby -v: ruby 3.2.0 (2022-12-25 revision a528908271) [x86_64-darwin20] * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- Ruby 3.1 ~~~ruby Ripper::Lexer.new("{a:,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nhelloworld").scan.map(&:tok) # => ["{", "a:", ",", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "", "\n", "helloworld"] ~~~ Ruby 3.2.0 ~~~ruby Ripper::Lexer.new("{a:,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nhelloworld").scan.map(&:tok) # => ["{", "a:", ",", "oworld\u0000\u0000\u0000\u0000\u0000\u0000z`\u0001\u0000\u0000\u0000\u0000\u0000\xC0\xF0$\u0010\u0001\u0000\u0000\u0000\x80A\xB8\u0019\xB5\u007F\u0000\u0000\x91\x94", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\n", "helloworld"] ~~~ -- https://bugs.ruby-lang.org/

2 1

[ruby-core:111563] [Ruby master Feature#16991] Sets: add Set#join
by zverok (Victor Shepelev) 01 Jan '23

01 Jan '23

Issue #16991 has been updated by zverok (Victor Shepelev). Status changed from Open to Closed Implemented in Ruby 3.0 ---------------------------------------- Feature #16991: Sets: add Set#join https://bugs.ruby-lang.org/issues/16991#change-100928 * Author: marcandre (Marc-Andre Lafortune) * Status: Closed * Priority: Normal ---------------------------------------- I'd like to add `#join` to `Set`: ```ruby # Now: Set[1, 2, 3].join('x') # => NoMethodError # After Set[1, 2, 3].join('x') # => "1x2x3" ``` I'd make this join never recursive. (I've never wanted to use the recursivity of `Array#join`, but it may very well just be my particular experience) Reminder: Why there is no `Enumerable#join`: https://bugs.ruby-lang.org/issues/1893 -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111562] [Ruby master Feature#16995] Sets: <=> should be specialized
by zverok (Victor Shepelev) 01 Jan '23

01 Jan '23

Issue #16995 has been updated by zverok (Victor Shepelev). Status changed from Open to Closed Implemented in Ruby 3.0: ```ruby Set[1] <=> Set[1, 2] # => -1 [Set[1], Set[1, 2]].sort # => [#<Set: {1}>, #<Set: {1, 2}>] ``` ---------------------------------------- Feature #16995: Sets: <=> should be specialized https://bugs.ruby-lang.org/issues/16995#change-100927 * Author: marcandre (Marc-Andre Lafortune) * Status: Closed * Priority: Normal ---------------------------------------- This is quite minor, but `Set#<=>` should be refined. Reminder: `Set` defines `<`, `>`, etc. as inclusion, but does not have a corresponding `<=>`: ```ruby Set[1] < Set[1, 2] # => true Set[1] <=> Set[1, 2] # => nil, should be -1 Set[1] <=> Set[2] # => nil, ok, not orderable ``` The official stated reason for `Set` to *not* implement is that some sets are not comparable. That is exactly what `nil` result type is for IMO. Sets are partically ordered and `<=>` should reflect that. https://en.wikipedia.org/wiki/Partially_ordered_set ```ruby Set[1] < Set[1, 2] # => true [Set[1], Set[1, 2]].sort # => ArgumentError, should be [Set[1], Set[1, 2]] [Set[1], Set[2]].sort # => ArgumentError, ok, can't be ordered ``` This is *exactly the same* idea as `Class`, which correctly refines `<=>`: ```ruby Array < Enumerable # => true Array <=> Enumerable # => -1, ok [Array, Enumerable].sort # => [Array, Enumerable] [Array, String].sort # => ArgumentError (comparison of Class with Class failed), ok ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111561] [Ruby master Feature#3591] Adding Numeric#divisor? (Have working implementation)
by e8c (Viktor Reznov) 01 Jan '23

01 Jan '23

Issue #3591 has been updated by e8c (Viktor Reznov). e8c (Viktor Reznov) wrote in #note-20: > Two solutions: 3rd: ```ruby def count_digits(n) = n.digits.count { n.modulo(_1).zero? } ``` ---------------------------------------- Feature #3591: Adding Numeric#divisor? (Have working implementation) https://bugs.ruby-lang.org/issues/3591#change-100926 * Author: duckinator (Marie Markwell) * Status: Rejected * Priority: Normal * Assignee: matz (Yukihiro Matsumoto) * Target version: 2.6 ---------------------------------------- =begin On the 'duckinator' branch of my fork of ruby on github, I have added Numeric#divisor?: num.divisor?(other) is the same as: (num % other == 0) Example usage: 4.divisor?(2) #=> true 1.divisor?(2) #=> false 2.4.divisor?(1.2) #=> true 2.4.divisor?(1.3) #=> false 126.divisor?(9) #=> true I think this would be a very nice feature to add, and would make code using the old (num % other == 0) method much cleaner and easier to understand. There is a unified diff of it: http://gist.github.com/raw/484144/07b1a6e696cd9301e658ccbc8f90dfcd4d4ef3f1/… The original commits can be seen here: http://github.com/RockerMONO/ruby/commit/f7959f964cb0bf38418904ccb5643db6b6… -- First attempt, only worked with Integers http://github.com/RockerMONO/ruby/commit/12376a6bb1c3ffbd4b470850dd758e2dcd… -- Second attempt, should work with anything derived from Numeric that can be used as (num % other == 0) =end -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111560] [Ruby master Feature#3591] Adding Numeric#divisor? (Have working implementation)
by e8c (Viktor Reznov) 01 Jan '23

01 Jan '23

Issue #3591 has been updated by e8c (Viktor Reznov). matz (Yukihiro Matsumoto) wrote in #note-19: > Is it more useful than `n % m == 0`? Yes, statement `n .has_divisor? m` (or `m .divisor_of? n`) has 3 parts instead of 5, and gives a direct answer to the question. The "problem": https://leetcode.com/problems/count-the-digits-that-divide-a-number/ Two solutions: ```ruby def count_digits(n) = n.digits.count { n % _1 == 0 } def count_digits(n) = n.digits.count { _1.divisor_of?(n) } ``` The first is shorter, but the second is clearer. ---------------------------------------- Feature #3591: Adding Numeric#divisor? (Have working implementation) https://bugs.ruby-lang.org/issues/3591#change-100925 * Author: duckinator (Marie Markwell) * Status: Rejected * Priority: Normal * Assignee: matz (Yukihiro Matsumoto) * Target version: 2.6 ---------------------------------------- =begin On the 'duckinator' branch of my fork of ruby on github, I have added Numeric#divisor?: num.divisor?(other) is the same as: (num % other == 0) Example usage: 4.divisor?(2) #=> true 1.divisor?(2) #=> false 2.4.divisor?(1.2) #=> true 2.4.divisor?(1.3) #=> false 126.divisor?(9) #=> true I think this would be a very nice feature to add, and would make code using the old (num % other == 0) method much cleaner and easier to understand. There is a unified diff of it: http://gist.github.com/raw/484144/07b1a6e696cd9301e658ccbc8f90dfcd4d4ef3f1/… The original commits can be seen here: http://github.com/RockerMONO/ruby/commit/f7959f964cb0bf38418904ccb5643db6b6… -- First attempt, only worked with Integers http://github.com/RockerMONO/ruby/commit/12376a6bb1c3ffbd4b470850dd758e2dcd… -- Second attempt, should work with anything derived from Numeric that can be used as (num % other == 0) =end -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111519] [Ruby master Bug#19285] (docs.rlo) Split stdlib and core documents
by zzak (Zak Scott) 01 Jan '23

01 Jan '23

Issue #19285 has been reported by zzak (Zak Scott). ---------------------------------------- Bug #19285: (docs.rlo) Split stdlib and core documents https://bugs.ruby-lang.org/issues/19285 * Author: zzak (Zak Scott) * Status: Open * Priority: Normal * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- It seems we merge all of the docs for stdlib and core into one for docs.ruby-lang.org, this creates weirdness like [Kernel](https://docs.ruby-lang.org/en/master/Kernel.html) which includes monkey patches for rubygems for example. > RubyGems adds the gem method to allow activation of specific gem versions and overrides the require method on Kernel to make gems appear as if they live on the $LOAD_PATH. See the documentation of these methods for further detail. -- https://bugs.ruby-lang.org/

2 1

[ruby-core:111549] [Ruby master Feature#16986] Anonymous Struct literal
by matz (Yukihiro Matsumoto) 31 Dec '22

31 Dec '22

Issue #16986 has been updated by matz (Yukihiro Matsumoto). If I have to pick one from either Struct or Data, I'd pick Data. But still don't like the notation proposed. Matz. ---------------------------------------- Feature #16986: Anonymous Struct literal https://bugs.ruby-lang.org/issues/16986#change-100913 * Author: ko1 (Koichi Sasada) * Status: Open * Priority: Normal * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- # Abstract How about introducing anonymous Struct literal such as `${a: 1, b: 2}`? It is almost the same as `Struct.new(:a, :b).new(1, 2)`. # Proposal ## Background In many cases, people use hash objects to represent a set of values such as `person = {name: "ko1", country: 'Japan'}` and access its values through `person[:name]` and so on. It is not easy to write (three characters `[:]`!), and it easily introduces misspelling (`person[:nama]` doesn't raise an error). If we make a `Struct` object by doing `Person = Struct.new(:name, :age)` and `person = Person.new('ko1', 'Japan')`, we can access its values through `person.name` naturally. However, it costs coding. And in some cases, we don't want to name the class (such as `Person`). Using `OpenStruct` (`person = OpenStruct.new(name: "ko1", country: "Japan")`), we can access it through `person.name`, but we can extend the fields unintentionally, and the performance is not good. Of course, we can define a class `Person` with attr_readers. But it takes several lines. To summarize the needs: * Easy to write * Doesn't require declaring the class * Accessible through `person.name` format * Limited fields * Better performance ## Idea Introduce new literal syntax for an anonymous Struct such as: `${ a: 1, b: 2 }`. Similar to Hash syntax (with labels), but with `$` prefix to distinguish. Anonymous structs which have the same member in the same order share their class. ```ruby s1 = ${a: 1, b: 2, c: 3} s2 = ${a: 1, b: 2, c: 3} assert s1 == s2 s3 = ${a: 1, c: 3, b: 2} s4 = ${d: 4} assert_equal false, s1 == s3 assert_equal false, s1 == s4 ``` ## Note Unlike Hash literal syntax, this proposal only allows `label: expr` notation. No `${**h}` syntax. This is because if we allow to splat a Hash, it can be a vulnerability by splatting outer-input Hash. Thanks to this spec, we can specify anonymous Struct classes at compile time. We don't need to find or create Struct classes at runtime. ## Implementatation https://github.com/ruby/ruby/pull/3259 # Discussion ## Notation Matz said he thought about `{|a: 1, b: 2 |}` syntax. ## Performance Surprisingly, Hash is fast and Struct is slow. ```ruby Benchmark.driver do |r| r.prelude <<~PRELUDE st = Struct.new(:a, :b).new(1, 2) hs = {a: 1, b: 2} class C attr_reader :a, :b def initialize() = (@a = 1; @b = 2) end ob = C.new PRELUDE r.report "ob.a" r.report "hs[:a]" r.report "st.a" end __END__ Warming up -------------------------------------- ob.a 38.100M i/s - 38.142M times in 1.001101s (26.25ns/i, 76clocks/i) hs[:a] 37.845M i/s - 38.037M times in 1.005051s (26.42ns/i, 76clocks/i) st.a 33.348M i/s - 33.612M times in 1.007904s (29.99ns/i, 87clocks/i) Calculating ------------------------------------- ob.a 87.917M i/s - 114.300M times in 1.300085s (11.37ns/i, 33clocks/i) hs[:a] 85.504M i/s - 113.536M times in 1.327850s (11.70ns/i, 33clocks/i) st.a 61.337M i/s - 100.045M times in 1.631064s (16.30ns/i, 47clocks/i) Comparison: ob.a: 87917391.4 i/s hs[:a]: 85503703.6 i/s - 1.03x slower st.a: 61337463.3 i/s - 1.43x slower ``` I believe we can speed up `Struct` similarly to ivar accesses, so we can improve the performance. BTW, OpenStruct (os.a) is slow. ``` Comparison: hs[:a]: 92835317.7 i/s ob.a: 85865849.5 i/s - 1.08x slower st.a: 53480417.5 i/s - 1.74x slower os.a: 12541267.7 i/s - 7.40x slower ``` For memory consumption, `Struct` is more lightweight because we don't need to keep the key names. ## Naming If we name an anonymous class, literals with the same members share the name. ```ruby s1 = ${a:1} s2 = ${a:2} p [s1, s2] #=> [#<struct a=1>, #<struct a=2>] A = s1.class p [s1, s2] #=> [#<struct A a=1>, #<struct A a=2>] ``` Maybe that is not a good behavior. -- https://bugs.ruby-lang.org/

2 1

[ruby-core:111551] [Ruby master Bug#19290] Documentation: "produces:" (introducing terminal output) is wrongly formatted in few places
by laurent_martin (Laurent Martin) 31 Dec '22

31 Dec '22

Issue #19290 has been reported by laurent_martin (Laurent Martin). ---------------------------------------- Bug #19290: Documentation: "produces:" (introducing terminal output) is wrongly formatted in few places https://bugs.ruby-lang.org/issues/19290 * Author: laurent_martin (Laurent Martin) * Status: Open * Priority: Normal * ruby -v: 3.3.0dev * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- ## `warning.rb` Problem: The text "produces:" is embedded in formatted text, it should be normal emphasized text. view here: https://ruby-doc.org/3.2.0/Kernel.html , 2 times after: "If warnings have been disabled" source: https://github.com/ruby/ruby/blob/master/warning.rb#L18 https://github.com/ruby/ruby/blob/master/warning.rb#L38 Fix: in both cases, remove one space character just before `produces:` ``` # produces: ``` shall be: ``` # produces: ``` ## `signal.c` Problem: the text "produces:" is not emphasized like others. view here: https://ruby-doc.org/3.2.0/Kernel.html after: "special signal name" view here: https://ruby-doc.org/3.2.0/Signal.html source: https://github.com/ruby/ruby/blob/master/signal.c#L1386 https://github.com/ruby/ruby/blob/master/signal.c#L1538 Fix: surround with `` and ``, and add a line after the line: (2 places) ``` * produces: ``` shall be: ``` * produces: * ``` -- https://bugs.ruby-lang.org/

1 1

[ruby-core:111550] [Ruby master Feature#16986] Anonymous Struct literal
by shyouhei (Shyouhei Urabe) 31 Dec '22

31 Dec '22

Issue #16986 has been updated by shyouhei (Shyouhei Urabe). JFYI JavaScript is having a similar proposal which now proposes `#{…}` syntax. https://github.com/tc39/proposal-record-tuple `#` is not a comment marker in that language though. ---------------------------------------- Feature #16986: Anonymous Struct literal https://bugs.ruby-lang.org/issues/16986#change-100914 * Author: ko1 (Koichi Sasada) * Status: Open * Priority: Normal * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- # Abstract How about introducing anonymous Struct literal such as `${a: 1, b: 2}`? It is almost the same as `Struct.new(:a, :b).new(1, 2)`. # Proposal ## Background In many cases, people use hash objects to represent a set of values such as `person = {name: "ko1", country: 'Japan'}` and access its values through `person[:name]` and so on. It is not easy to write (three characters `[:]`!), and it easily introduces misspelling (`person[:nama]` doesn't raise an error). If we make a `Struct` object by doing `Person = Struct.new(:name, :age)` and `person = Person.new('ko1', 'Japan')`, we can access its values through `person.name` naturally. However, it costs coding. And in some cases, we don't want to name the class (such as `Person`). Using `OpenStruct` (`person = OpenStruct.new(name: "ko1", country: "Japan")`), we can access it through `person.name`, but we can extend the fields unintentionally, and the performance is not good. Of course, we can define a class `Person` with attr_readers. But it takes several lines. To summarize the needs: * Easy to write * Doesn't require declaring the class * Accessible through `person.name` format * Limited fields * Better performance ## Idea Introduce new literal syntax for an anonymous Struct such as: `${ a: 1, b: 2 }`. Similar to Hash syntax (with labels), but with `$` prefix to distinguish. Anonymous structs which have the same member in the same order share their class. ```ruby s1 = ${a: 1, b: 2, c: 3} s2 = ${a: 1, b: 2, c: 3} assert s1 == s2 s3 = ${a: 1, c: 3, b: 2} s4 = ${d: 4} assert_equal false, s1 == s3 assert_equal false, s1 == s4 ``` ## Note Unlike Hash literal syntax, this proposal only allows `label: expr` notation. No `${**h}` syntax. This is because if we allow to splat a Hash, it can be a vulnerability by splatting outer-input Hash. Thanks to this spec, we can specify anonymous Struct classes at compile time. We don't need to find or create Struct classes at runtime. ## Implementatation https://github.com/ruby/ruby/pull/3259 # Discussion ## Notation Matz said he thought about `{|a: 1, b: 2 |}` syntax. ## Performance Surprisingly, Hash is fast and Struct is slow. ```ruby Benchmark.driver do |r| r.prelude <<~PRELUDE st = Struct.new(:a, :b).new(1, 2) hs = {a: 1, b: 2} class C attr_reader :a, :b def initialize() = (@a = 1; @b = 2) end ob = C.new PRELUDE r.report "ob.a" r.report "hs[:a]" r.report "st.a" end __END__ Warming up -------------------------------------- ob.a 38.100M i/s - 38.142M times in 1.001101s (26.25ns/i, 76clocks/i) hs[:a] 37.845M i/s - 38.037M times in 1.005051s (26.42ns/i, 76clocks/i) st.a 33.348M i/s - 33.612M times in 1.007904s (29.99ns/i, 87clocks/i) Calculating ------------------------------------- ob.a 87.917M i/s - 114.300M times in 1.300085s (11.37ns/i, 33clocks/i) hs[:a] 85.504M i/s - 113.536M times in 1.327850s (11.70ns/i, 33clocks/i) st.a 61.337M i/s - 100.045M times in 1.631064s (16.30ns/i, 47clocks/i) Comparison: ob.a: 87917391.4 i/s hs[:a]: 85503703.6 i/s - 1.03x slower st.a: 61337463.3 i/s - 1.43x slower ``` I believe we can speed up `Struct` similarly to ivar accesses, so we can improve the performance. BTW, OpenStruct (os.a) is slow. ``` Comparison: hs[:a]: 92835317.7 i/s ob.a: 85865849.5 i/s - 1.08x slower st.a: 53480417.5 i/s - 1.74x slower os.a: 12541267.7 i/s - 7.40x slower ``` For memory consumption, `Struct` is more lightweight because we don't need to keep the key names. ## Naming If we name an anonymous class, literals with the same members share the name. ```ruby s1 = ${a:1} s2 = ${a:2} p [s1, s2] #=> [#<struct a=1>, #<struct a=2>] A = s1.class p [s1, s2] #=> [#<struct A a=1>, #<struct A a=2>] ``` Maybe that is not a good behavior. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111548] [Ruby master Feature#16986] Anonymous Struct literal
by Bumppoman (Brendon Stanton) 31 Dec '22

31 Dec '22

Issue #16986 has been updated by Bumppoman (Brendon Stanton). In a Ruby 3.2 context, I wonder how this would look in the mindset of the new Data class instead of a struct? ---------------------------------------- Feature #16986: Anonymous Struct literal https://bugs.ruby-lang.org/issues/16986#change-100912 * Author: ko1 (Koichi Sasada) * Status: Open * Priority: Normal * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- # Abstract How about introducing anonymous Struct literal such as `${a: 1, b: 2}`? It is almost the same as `Struct.new(:a, :b).new(1, 2)`. # Proposal ## Background In many cases, people use hash objects to represent a set of values such as `person = {name: "ko1", country: 'Japan'}` and access its values through `person[:name]` and so on. It is not easy to write (three characters `[:]`!), and it easily introduces misspelling (`person[:nama]` doesn't raise an error). If we make a `Struct` object by doing `Person = Struct.new(:name, :age)` and `person = Person.new('ko1', 'Japan')`, we can access its values through `person.name` naturally. However, it costs coding. And in some cases, we don't want to name the class (such as `Person`). Using `OpenStruct` (`person = OpenStruct.new(name: "ko1", country: "Japan")`), we can access it through `person.name`, but we can extend the fields unintentionally, and the performance is not good. Of course, we can define a class `Person` with attr_readers. But it takes several lines. To summarize the needs: * Easy to write * Doesn't require declaring the class * Accessible through `person.name` format * Limited fields * Better performance ## Idea Introduce new literal syntax for an anonymous Struct such as: `${ a: 1, b: 2 }`. Similar to Hash syntax (with labels), but with `$` prefix to distinguish. Anonymous structs which have the same member in the same order share their class. ```ruby s1 = ${a: 1, b: 2, c: 3} s2 = ${a: 1, b: 2, c: 3} assert s1 == s2 s3 = ${a: 1, c: 3, b: 2} s4 = ${d: 4} assert_equal false, s1 == s3 assert_equal false, s1 == s4 ``` ## Note Unlike Hash literal syntax, this proposal only allows `label: expr` notation. No `${**h}` syntax. This is because if we allow to splat a Hash, it can be a vulnerability by splatting outer-input Hash. Thanks to this spec, we can specify anonymous Struct classes at compile time. We don't need to find or create Struct classes at runtime. ## Implementatation https://github.com/ruby/ruby/pull/3259 # Discussion ## Notation Matz said he thought about `{|a: 1, b: 2 |}` syntax. ## Performance Surprisingly, Hash is fast and Struct is slow. ```ruby Benchmark.driver do |r| r.prelude <<~PRELUDE st = Struct.new(:a, :b).new(1, 2) hs = {a: 1, b: 2} class C attr_reader :a, :b def initialize() = (@a = 1; @b = 2) end ob = C.new PRELUDE r.report "ob.a" r.report "hs[:a]" r.report "st.a" end __END__ Warming up -------------------------------------- ob.a 38.100M i/s - 38.142M times in 1.001101s (26.25ns/i, 76clocks/i) hs[:a] 37.845M i/s - 38.037M times in 1.005051s (26.42ns/i, 76clocks/i) st.a 33.348M i/s - 33.612M times in 1.007904s (29.99ns/i, 87clocks/i) Calculating ------------------------------------- ob.a 87.917M i/s - 114.300M times in 1.300085s (11.37ns/i, 33clocks/i) hs[:a] 85.504M i/s - 113.536M times in 1.327850s (11.70ns/i, 33clocks/i) st.a 61.337M i/s - 100.045M times in 1.631064s (16.30ns/i, 47clocks/i) Comparison: ob.a: 87917391.4 i/s hs[:a]: 85503703.6 i/s - 1.03x slower st.a: 61337463.3 i/s - 1.43x slower ``` I believe we can speed up `Struct` similarly to ivar accesses, so we can improve the performance. BTW, OpenStruct (os.a) is slow. ``` Comparison: hs[:a]: 92835317.7 i/s ob.a: 85865849.5 i/s - 1.08x slower st.a: 53480417.5 i/s - 1.74x slower os.a: 12541267.7 i/s - 7.40x slower ``` For memory consumption, `Struct` is more lightweight because we don't need to keep the key names. ## Naming If we name an anonymous class, literals with the same members share the name. ```ruby s1 = ${a:1} s2 = ${a:2} p [s1, s2] #=> [#<struct a=1>, #<struct a=2>] A = s1.class p [s1, s2] #=> [#<struct A a=1>, #<struct A a=2>] ``` Maybe that is not a good behavior. -- https://bugs.ruby-lang.org/

1 0