# struct Set(T)

## Overview

Set implements a collection of unordered values with no duplicates.

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:

• Equality of elements is determined according to `Object#==` and

`Object#hash`.

• Set assumes that the identity of each element does not change while it is

stored. Modifying an element of a set will render the set to an unreliable state.

### Example

``````s1 = Set{1, 2}
s2 = [1, 2].to_set
s3 = Set.new [1, 2]
s1 == s2         # => true
s1 == s3         # => true
s1.merge([6,8])
s1.subset? s2    # => false
s2.subset? s1    # => true``````

set.cr
json/to_json.cr
yaml/to_yaml.cr

## Instance Method Summary

• #&(other : Set)

Intersection: returns a new set containing elements common to both sets.

• #-(other : Set)

Difference: returns a new set containing elements in this set that are not present in the other.

• #-(other : Enumerable)

Difference: returns a new set containing elements in this set that are not present in the other enumerable.

• #<<(object : T)

Alias for `#add`

• #==(other : Set)

Returns `true` if both sets have the same elements

• #^(other : Enumerable(U))

Symmetric Difference: returns a new set `(self - other) | (other - self)`.

• #^(other : Set(U))

Symmetric Difference: returns a new set `(self - other) | (other - self)`.

Adds `object` to the set and returns `self`

• #clear

Removes all elements in the set, and returns `self`.

• #clone

Returns a new set with all of the elements cloned.

• #delete(object)

Removes the object from the set and returns `self`.

• #dup

Returns a new set with all of the same elements

• #each(&block)

Yields each element of the set, and returns `self`.

• #each

Returns an iterator for each element of the set.

• #empty?

Returns `true` if the set is empty.

• #hash
• #includes?(object)

Returns `true` if object exists in the set.

• #inspect(io)

Alias of `#to_s`

• #intersects?(other : Set)

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

• #merge(elems)

Adds `#each` element of elems to the set and returns `self`.

• #proper_subset?(other : Set)

Returns `true` if the set is a proper subset of the `other` set

• #proper_superset?(other : Set)

Returns `true` if the set is a superset of the `other` set

• #size

Returns the number of elements in the set.

• #subset?(other : Set)

Returns `true` if the set is a subset of the `other` set

• #subtract(other : Enumerable)

Returns `self` after removing from it those elements that are present in the given enumerable.

• #superset?(other : Set)

Returns `true` if the set is a superset of the `other` set

• #to_a

Returns the elements as an array

• #to_json(io)
• #to_s(io)

Writes a string representation of the set to `io`

• #to_yaml(yaml : YAML::Generator)
• #|(other : Set(U))

Union: returns a new set containing all unique elements from both sets.

## Class Method Detail

def self.new(initial_capacity = nil) #

Creates a new, empty `Set`

``````s = Set(Int32).new
set.empty? # => true``````

An initial capacity can be specified, and it will be set as the initial capacity of the internal Hash.

def self.new(pull : JSON::PullParser) #

def self.new(enumerable : Enumerable(T)) #

Creates a new set from the elements in `enumerable`

``````s = Set.new [1,3,5]
s.empty? => false``````

## Instance Method Detail

def &(other : Set) #

Intersection: returns a new set containing elements common to both sets.

``````Set.new([1,1,3,5]) & Set.new([1,2,3])               #=> Set{1, 3}
Set.new(['a','b','b','z']) & Set.new(['a','b','c']) #=> Set{'a', 'b'}``````

def -(other : Set) #

Difference: returns a new set containing elements in this set that are not present in the other.

``````Set.new([1,2,3,4,5]) - Set.new([2,4])               #=> Set{1, 3, 5}
Set.new(['a','b','b','z']) - Set.new(['a','b','c']) #=> Set{'z'}``````

def -(other : Enumerable) #

Difference: returns a new set containing elements in this set that are not present in the other enumerable.

``````Set.new([1,2,3,4,5]) - [2,4]               #=> Set{1, 3, 5}
Set.new(['a','b','b','z']) - ['a','b','c'] #=> Set{'z'}``````

def <<(object : T) #

Alias for `#add`

def ==(other : Set) #

Returns `true` if both sets have the same elements

``Set.new([1,5]) == Set.new([1,5]) # => true``

def ^(other : Enumerable(U)) #

Symmetric Difference: returns a new set `(self - other) | (other - self)`. Equivalently, returns `(self | other) - (self & other)`.

``````Set.new([1,2,3,4,5]) ^ [2,4,6]             #=> Set{1, 3, 5, 6}
Set.new(['a','b','b','z']) ^ ['a','b','c'] #=> Set{'z', 'c'}``````

def ^(other : Set(U)) #

Symmetric Difference: returns a new set `(self - other) | (other - self)`. Equivalently, returns `(self | other) - (self & other)`.

``````Set.new([1,2,3,4,5]) ^ Set.new([2,4,6])             #=> Set{1, 3, 5, 6}
Set.new(['a','b','b','z']) ^ Set.new(['a','b','c']) #=> Set{'z', 'c'}``````

Adds `object` to the set and returns `self`

``````s = Set.new [1,5]
s.includes? 8     # => false
s << 8
s.includes? 8     # => true``````

def clear #

Removes all elements in the set, and returns `self`.

``````s = Set.new [1,5]
s.size  # => 2
s.clear
s.size  # => 0``````

def clone #

Returns a new set with all of the elements cloned.

def delete(object) #

Removes the object from the set and returns `self`.

``````s = Set.new [1,5]
s.includes? 5  # => true
s.delete 5
s.includes? 5  # => false``````

def dup #

Returns a new set with all of the same elements

def each(&block) #

Yields each element of the set, and returns `self`.

def each #

Returns an iterator for each element of the set.

def empty? #

Returns `true` if the set is empty.

``````s = Set(Int32).new
s.empty? # => true
s << 3
s.empty? # => false``````

def hash #

def includes?(object) #

Returns `true` if object exists in the set.

``````s = Set.new [1,5]
s.includes? 5  # => true
s.includes? 9  # => false``````

def inspect(io) #

Alias of `#to_s`

def intersects?(other : Set) #

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

``````Set{1, 2, 3}.intersects? Set{4, 5} # => false
Set{1, 2, 3}.intersects? Set{3, 4} # => true``````

def merge(elems) #

Adds `#each` element of elems to the set and returns `self`.

``````s = Set.new [1,5]
s.merge [5,5,8,9]
s.size            # => 4``````

def proper_subset?(other : Set) #

Returns `true` if the set is a proper subset of the `other` set

This set must have fewer elements than the `other` set, and all of elements in this set must be present in the `other` set.

``````Set.new([1,5]).subset? Set.new([1,3,5])   # => true
Set.new([1,3,5]).subset? Set.new([1,3,5]) # => false``````

def proper_superset?(other : Set) #

Returns `true` if the set is a superset of the `other` set

The `other` must have the same or fewer elements than this set, and all of elements in the `other` set must be present in this set.

``````Set.new([1,3,5]).superset? Set.new([1,5])   # => true
Set.new([1,3,5]).superset? Set.new([1,3,5]) # => false``````

def size #

Returns the number of elements in the set.

``````s = Set.new [1,5]
s.size  # => 2``````

def subset?(other : Set) #

Returns `true` if the set is a subset of the `other` set

This set must have the same or fewer elements than the `other` set, and all of elements in this set must be present in the `other` set.

``````Set.new([1,5]).subset? Set.new([1,3,5])   # => true
Set.new([1,3,5]).subset? Set.new([1,3,5]) # => true``````

def subtract(other : Enumerable) #

Returns `self` after removing from it those elements that are present in the given enumerable.

``````Set.new(['a','b','b','z']).subtract Set.new(['a','b','c']) #=> Set{'z'}
Set.new([1,2,3,4,5]).subtract [2,4,6] #=> Set{1, 3, 5}``````

def superset?(other : Set) #

Returns `true` if the set is a superset of the `other` set

The `other` must have the same or fewer elements than this set, and all of elements in the `other` set must be present in this set.

``````Set.new([1,3,5]).superset? Set.new([1,5])   # => true
Set.new([1,3,5]).superset? Set.new([1,3,5]) # => true``````

def to_a #

Returns the elements as an array

``Set.new([1,5]).to_a  # => [1,5]``

def to_json(io) #

def to_s(io) #

Writes a string representation of the set to `io`

def to_yaml(yaml : YAML::Generator) #

def |(other : Set(U)) #

Union: returns a new set containing all unique elements from both sets.

``````Set.new([1,1,3,5]) | Set.new([1,2,3])               #=> Set{1, 3, 5, 2}
Set.new(['a','b','b','z']) | Set.new(['a','b','c']) #=> Set{'a', 'b', 'z', 'c'}``````