From: zn@...
Date: 2018-06-29T11:08:11+00:00
Subject: [ruby-core:87689] [Ruby trunk Feature#14869] Proposal to add	Hash#===

Issue #14869 has been updated by znz (Kazuhiro NISHIYAMA).


������������������������ `Hash#<=` ������������������������������������������
`{} <= user` ��� `true` ������������������`{} === user` ��� `true` ��������� `<=` ������������������ `===` ������������������������������������������������������������������������������������������������������

----------------------------------------
Feature #14869: Proposal to add Hash#===
https://bugs.ruby-lang.org/issues/14869#change-72709

* 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 (2.36 KB)
hash_eqq.patch (2.69 KB)


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

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>