From: knu@... Date: 2021-01-13T01:26:43+00:00 Subject: [ruby-core:102043] [Ruby master Feature#16989] Sets: need ♥️ Issue #16989 has been updated by knu (Akinori MUSHA). I don't like the idea of making `array & hash` possible, as that would go against the trends of making Ruby type-friendly and error-prone. akr (Akira Tanaka) wrote in #note-25: > - define a special constant (Hash::DummyValue = Object.new) > - Hash#inspect doesn't show the value: {1 => Hash::DummyValue}.inspect #=> "{1}" > - `{}` can be used as an empty set > - `hash << v` would be defined as `hash[v] = Hash::DummyValue` > - Hash#each doesn't work well as Set but we can use Hash#each_key. > - Hash#to_a doesn't work well as Set but we can use Hash#keys. I'd appreciate the list as implementation details, but if it were like some hashes are used as sets, programs might get less readable. For example, a program that goes `hash = {}; hash << 1; hash[:key] = :value` would likely be a mistake, but that couldn't be easily detected without explicit type annotation. ---------------------------------------- Feature #16989: Sets: need ������ https://bugs.ruby-lang.org/issues/16989#change-89895 * Author: marcandre (Marc-Andre Lafortune) * Status: Assigned * Priority: Normal * Assignee: knu (Akinori MUSHA) ---------------------------------------- I am opening a series of feature requests on `Set`, all of them based on this usecase. The main usecase I have in mind is my recent experience with `RuboCop`. I noticed a big number of frozen arrays being used only to later call `include?` on them. This is `O(n)` instead of `O(1)`. Trying to convert them to `Set`s causes major compatibility issues, as well as very frustrating situations and some cases that would make them much less efficient. Because of these incompatibilities, `RuboCop` is in the process of using a custom class based on `Array` with optimized `include?` and `===`. `RuboCop` runs multiple checks on Ruby code. Those checks are called cops. `RuboCop` performance is (IMO) pretty bad and some cops currently are in `O(n^2)` where n is the size of the code being inspected. Even given these extremely inefficient cops, optimizing the 100+ such arrays (most of which are quite small btw) gave a 5% speed boost. RuboCop PRs for reference: https://github.com/rubocop-hq/rubocop-ast/pull/29 https://github.com/rubocop-hq/rubocop/pull/8133 My experience tells me that there are many other opportunities to use `Set`s that are missed because `Set`s are not builtin, not known enough and have no shorthand notation. In this issue I'd like to concentrate the discussion on the following request: `Set`s should be core objects, in the same way that `Complex` were not and are now. Some of the upcoming feature requests would be easier (or only possible) to implement were `Set`s builtin. -- https://bugs.ruby-lang.org/ Unsubscribe: