# Set

Class

`Set` implements a collection of unordered values with no duplicates. This is a hybrid of Array's intuitive inter-operation facilities and Hash's fast lookup.

`Set` is easy to use with `Enumerable` objects (implementing `each`). Most of the initializer methods and binary operators accept generic `Enumerable` objects besides sets and arrays. An `Enumerable` object can be converted to `Set` using the `to_set` method.

`Set` uses `Hash` as storage, so you must note the following points:

## Comparison

The comparison operators <, >, <=, and >= are implemented as shorthand for the {proper_,}{subset?,superset?} methods. However, the <=> operator is intentionally left out because not every pair of sets is comparable ({x, y} vs. {x, z} for example).

## Example

```require 'set'
s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
s1 == s2                              #=> true
s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
s1.subset?(s2)                        #=> false
s2.subset?(s1)                        #=> true
```

## Contact

`- Akinori MUSHA <knu@iDaemons.org> (current maintainer)`

#### &

#

Returns a new set containing elements common to the set and the given enumerable object.

```Set[1, 3, 5] & Set[3, 2, 1]             #=> #<Set: {3, 1}>
Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> #<Set: {"a", "b"}>
```

#### +

#
No documentation available

#### -

#

Returns a new set built by duplicating the set, removing every element that appears in the given enumerable object.

```Set[1, 3, 5] - Set[1, 5]                #=> #<Set: {3}>
Set['a', 'b', 'z'] - ['a', 'c']         #=> #<Set: {"b", "z"}>
```

#### <

#
No documentation available

#### <<

#
No documentation available

#### <=

#
No documentation available

#### ==

#

Returns true if two sets are equal. The equality of each couple of elements is defined according to `Object#eql?`.

```Set[1, 2] == Set[2, 1]                       #=> true
Set[1, 3, 5] == Set[1, 5]                    #=> false
Set['a', 'b', 'c'] == Set['a', 'c', 'b']     #=> true
Set['a', 'b', 'c'] == ['a', 'c', 'b']        #=> false
```

#### ===

#

Returns true if the given object is a member of the set, and false otherwise.

Used in case statements:

```require 'set'

case :apple
when Set[:potato, :carrot]
"vegetable"
when Set[:apple, :banana]
"fruit"
end
# => "fruit"
```

Or by itself:

```Set[1, 2, 3] === 2   #=> true
Set[1, 2, 3] === 4   #=> false
```

#### >

#
No documentation available

#### >=

#
No documentation available

#### []

::

Creates a new set containing the given objects.

```Set[1, 2]                   # => #<Set: {1, 2}>
Set[1, 2, 1]                # => #<Set: {1, 2}>
Set[1, 'c', :s]             # => #<Set: {1, "c", :s}>
```

#### ^

#

Returns a new set containing elements exclusive between the set and the given enumerable object. (set ^ enum) is equivalent to ((set | enum) - (set & enum)).

```Set[1, 2] ^ Set[2, 3]                   #=> #<Set: {3, 1}>
Set[1, 'b', 'c'] ^ ['b', 'd']           #=> #<Set: {"d", 1, "c"}>
```

#

Adds the given object to the set and returns self. Use `merge` to add many elements at once.

```Set[1, 2].add(3)                    #=> #<Set: {1, 2, 3}>
Set[1, 2].add([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
Set[1, 2].add(2)                    #=> #<Set: {1, 2}>
```

#

Adds the given object to the set and returns self. If the object is already in the set, returns nil.

```Set[1, 2].add?(3)                    #=> #<Set: {1, 2, 3}>
Set[1, 2].add?([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
```

#### as_json

#

`Marshal` the object to `JSON`.

method used for `JSON` marshalling support.

#### classify

#

Classifies the set by the return value of the given block and returns a hash of {value => set of elements} pairs. The block is called once for each element of the set, passing the element as parameter.

```require 'set'
files = Set.new(Dir.glob("*.rb"))
hash = files.classify { |f| File.mtime(f).year }
hash       #=> {2000=>#<Set: {"a.rb", "b.rb"}>,
#    2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
#    2002=>#<Set: {"f.rb"}>}
```

Returns an enumerator if no block is given.

#### clear

#

Removes all elements and returns self.

```set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
set.clear                         #=> #<Set: {}>
set                               #=> #<Set: {}>
```

#### collect!

#

Replaces the elements with ones returned by collect(). Returns an enumerator if no block is given.

#### compare_by_identity

#

Makes the set compare its elements by their identity and returns self. This method may not be supported by all subclasses of `Set`.

#### compare_by_identity?

#

Returns true if the set will compare its elements by their identity. Also see `Set#compare_by_identity`.

#### delete

#

Deletes the given object from the set and returns self. Use `subtract` to delete many items at once.

#### delete?

#

Deletes the given object from the set and returns self. If the object is not in the set, returns nil.

#### delete_if

#

Deletes every element of the set for which block evaluates to true, and returns self. Returns an enumerator if no block is given.

#### difference

#
No documentation available

#### disjoint?

#

Returns true if the set and the given set have no element in common. This method is the opposite of `intersect?`.

```Set[1, 2, 3].disjoint? Set[3, 4]   #=> false
Set[1, 2, 3].disjoint? Set[4, 5]   #=> true
```

#### divide

#

Divides the set into a set of subsets according to the commonality defined by the given block.

If the arity of the block is 2, elements o1 and o2 are in common if block.call(o1, o2) is true. Otherwise, elements o1 and o2 are in common if block.call(o1) == block.call(o2).

```require 'set'
numbers = Set[1, 3, 4, 6, 9, 10, 11]
set = numbers.divide { |i,j| (i - j).abs == 1 }
set        #=> #<Set: {#<Set: {1}>,
#           #<Set: {11, 9, 10}>,
#           #<Set: {3, 4}>,
#           #<Set: {6}>}>
```

Returns an enumerator if no block is given.

#### each

#

Calls the given block once for each element in the set, passing the element as parameter. Returns an enumerator if no block is given.

#### empty?

#

Returns true if the set contains no elements.

#

#### flatten

#

Returns a new set that is a copy of the set, flattening each containing set recursively.

#### flatten!

#

Equivalent to `Set#flatten`, but replaces the receiver with the result in place. Returns nil if no modifications were made.

#### include?

#

Returns true if the set contains the given object.

Note that `include?` and `member?` do not test member equality using `==` as do other Enumerables.

See also `Enumerable#include?`

#### initialize_clone

#

Clone internal hash.

#### initialize_dup

#

Dup internal hash.

#### inspect

#

Returns a string containing a human-readable representation of the set (“#<Set: {element1, element2, …}>”).

#### intersect?

#

Returns true if the set and the given set have at least one element in common.

```Set[1, 2, 3].intersect? Set[4, 5]   #=> false
Set[1, 2, 3].intersect? Set[3, 4]   #=> true
```

#### intersection

#
No documentation available

#### json_create

::

Import a `JSON` Marshalled object.

method used for `JSON` marshalling support.

#### keep_if

#

Deletes every element of the set for which block evaluates to false, and returns self. Returns an enumerator if no block is given.

#### length

#
No documentation available

#### map!

#
No documentation available

#### member?

#
No documentation available

#### merge

#

Merges the elements of the given enumerable object to the set and returns self.

#### new

::

Creates a new set containing the elements of the given enumerable object.

If a block is given, the elements of enum are preprocessed by the given block.

```Set.new([1, 2])                       #=> #<Set: {1, 2}>
Set.new([1, 2, 1])                    #=> #<Set: {1, 2}>
Set.new([1, 'c', :s])                 #=> #<Set: {1, "c", :s}>
Set.new(1..5)                         #=> #<Set: {1, 2, 3, 4, 5}>
Set.new([1, 2, 3]) { |x| x * x }      #=> #<Set: {1, 4, 9}>
```

#### proper_subset?

#

Returns true if the set is a proper subset of the given set.

#### proper_superset?

#

Returns true if the set is a proper superset of the given set.

#### reject!

#

Equivalent to `Set#delete_if`, but returns nil if no changes were made. Returns an enumerator if no block is given.

#### replace

#

Replaces the contents of the set with the contents of the given enumerable object and returns self.

```set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
set.replace([1, 2])               #=> #<Set: {1, 2}>
set                               #=> #<Set: {1, 2}>
```

#### reset

#

Resets the internal state after modification to existing elements and returns self.

Elements will be reindexed and deduplicated.

#### select!

#

Equivalent to `Set#keep_if`, but returns nil if no changes were made. Returns an enumerator if no block is given.

#### size

#

Returns the number of elements.

#### subset?

#

Returns true if the set is a subset of the given set.

#### subtract

#

Deletes every element that appears in the given enumerable object and returns self.

#### superset?

#

Returns true if the set is a superset of the given set.

#### to_a

#

Converts the set to an array. The order of elements is uncertain.

```Set[1, 2].to_a                    #=> [1, 2]
Set[1, 'c', :s].to_a              #=> [1, "c", :s]
```

#### to_json

#

return the `JSON` value

#### to_s

#
No documentation available

#### to_set

#

Returns self if no arguments are given. Otherwise, converts the set to another with klass.new(self, *args, &block).

In subclasses, returns klass.new(self, *args, &block) unless overridden.

#### union

#
No documentation available

#### |

#

Returns a new set built by merging the set and the elements of the given enumerable object.

```Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>
```