# 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}>
```