From: keystonelemur@... Date: 2018-08-04T15:55:38+00:00 Subject: [ruby-core:88289] [Ruby trunk Feature#14869] Proposal to add Hash#=== Issue #14869 has been updated by baweaver (Brandon Weaver). I would agree with `===` being more useful than `<=`, as `case`, `all?`, `grep`, and other methods use it implicitly. This would be an amazing addition for Ruby, and would bring us closer to pattern matching syntax. The great part about this is your implementation uses `===` to compare values as well. This makes it very flexible, and extremely useful. **Aside / Offtopic** This may be unrelated, and if so feel free to tell me to open another issue, but what if it worked on Objects: ``` Person = Struct.new(:id, :name, :age) people = [{:id=>1, :name=>"Homu", :age=>13}, {:id=>2, :name=>"mami", :age=>14}].map { |p| Person.new(*p.values) } people.grep(age: 10..13) # => [#] ``` ---------------------------------------- Feature #14869: Proposal to add Hash#=== https://bugs.ruby-lang.org/issues/14869#change-73313 * Author: osyo (manga osyo) * Status: Open * Priority: Normal * Assignee: * Target version: ---------------------------------------- ## ������ `Hash#===` ��������������������������������������� ## ������ ��������������������������������������������������������������������������� `#===` ������������������������������������ `true` ��������������������������������� `false` ������������ ��������������������������������������������������������������������������������������� `true` ��������������������������������� `false` ������������ ```ruby user = { id: 1, name: "homu", age: 14 } # name ��������� data ��������������� true p ({ name: "homu" } === user) # => true # ������������������������������ OK p ({ id: 1, name: "homu", age: 14 } === user) # => true # name ��������� user ��������������������������������� false p ({ name: "name" } === user) # => false # ��������������������������������������� false p ({ number: 42 } === user) # => false # 1������������������������������������������ false p ({ id: 1, name: "homu", number: 42 } === user) # => false # ��������������������������������������� false p ({} == user) # => false # ������������������������������ true p ({} == {}) # => true # ��������������������������������� false p ({ id: 42 } == 42) # => false # #=== ��������������������������������������������������������� p ({ name: /^h/ } === user) # => true p ({ age: (1..20) } === user) # => true p ({ age: Integer } === user) # => true ``` ## ������������������ ### ��������������������� case-when ������ `===` ������������������������������������������������`Hash#===` ��������������������������������������������������������������������������������� ```ruby def validation user case user # name ��������������������������������� when { name: /^[a-z]/ } raise "������������������������������������������������������������" # age ��������������������������������� when { age: (0..20) } raise "0���20���������������������������" # ��������������������������������������������������������������������������������������� when { id: Integer, name: String, age: Integer } true else false end end # ��������������������������������� OK mami = { id: 1, name: "Mami", age: 21 } validation mami # => true # name ������������������������������������������ NG mado = { id: 2, name: "mado", age: 13 } validation mado # => ������������������������������������������������������������ (RuntimeError) # age ��� 0���20������������������ NG homu = { id: 3, name: "Homu", age: 14 } validation homu # => 0���20��������������������������� (RuntimeError) ``` ### `Enumerable#grep` `Enumerable#grep` ������������ `===` ������������������������������������������������������������������������ Hash ������������������������������������������������������������������ ```ruby data = [ { id: 1, name: "Homu", age: 13 }, { id: 2, name: "mami", age: 14 }, { id: 3, name: "Mado", age: 21 }, { id: 4, name: "saya", age: 14 }, ] # ������������������������������������ Hash ��������������������� p data.grep(name: /m/) # => [{:id=>1, :name=>"Homu", :age=>13}, {:id=>2, :name=>"mami", :age=>14}] p data.grep(age: (1..20)) # => [{:id=>1, :name=>"Homu", :age=>13}, {:id=>2, :name=>"mami", :age=>14}, {:id=>4, :name=>"saya", :age=>14}] ``` ## ������1��� `==` ��������������� `===` ��������������������� * `===` ��������������������������������������������������������������������������������������������� * `Class` ��� `Regexp`���`Proc` ��������������������������������������� * ��������� `===` ������������������������������ `==` ��������������������������� `obj.method(:==)` ��������������������������������������������������������� * ��������� `==` ������������������������������ `===` ��������������������������������������� ## ������2��� ��������������������������������������� * `Object#===` ��������������� `{} === 42` ������������������������ `false` ���������������������������`Hash#===` ��� `false` ������������������������ * `{} === {}` ��� `true` ��������������������������������������������� * ������������������������������������������������������������������������������������������������������������������ ```ruby def check n case n when {} "Empty Hash" when [] "Empty Array" when 0 "Zero" else "Not empty" end end p check({}) # => "Empty Hash" p check([]) # => "Empty Array" p check(0) # => "Zero" p check({ name: "mado" }) # => "Not empty" ``` ���������`Hash#===` ������������������������������������ ��������������������������������������������������������������������������������������������������������� ---Files-------------------------------- hash_eqq.patch (3.54 KB) -- https://bugs.ruby-lang.org/ Unsubscribe: