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.add(2)
s1.concat([6, 8])
s1.subset? s2 # => false
s2.subset? s1 # => true``````

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

Constructor Detail

def self.new(other : Indexable(T)) #

Optimized version of `new` used when other is also an `Indexable`

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

Creates a new set from the elements in enumerable.

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

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

def self.new(initial_capacity = nil) #

Creates a new, empty `Set`.

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

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

Instance Method Detail

def &(other : Set) #

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

``````Set{1, 1, 3, 5} & Set{1, 2, 3}               # => Set{1, 3}
Set{'a', 'b', 'b', 'z'} & Set{'a', 'b', 'c'} # => Set{'a', 'b'}``````

def -(other : Enumerable) #

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

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

def -(other : Set) #

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

``````Set{1, 2, 3, 4, 5} - Set{2, 4}               # => Set{1, 3, 5}
Set{'a', 'b', 'b', 'z'} - Set{'a', 'b', 'c'} # => Set{'z'}``````

def <<(object : T) #

Alias for `#add`

def ==(other : Set) #

Returns `true` if both sets have the same elements.

``Set{1, 5} == Set{1, 5} # => true``

def ===(object : T) #

Same as `#includes?`.

It is for convenience with using on `case` statement.

``````red_like = Set{"red", "pink", "violet"}
blue_like = Set{"blue", "azure", "violet"}

case "violet"
when red_like & blue_like
puts "red & blue like color!"
when red_like
puts "red like color!"
when blue_like
puts "blue like color!"
end``````

See also: `Object#===`.

def ^(other : Enumerable(U)) forall U #

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

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

def ^(other : Set(U)) forall U #

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

``````Set{1, 2, 3, 4, 5} ^ Set{2, 4, 6}            # => Set{1, 3, 5, 6}
Set{'a', 'b', 'b', 'z'} ^ Set{'a', 'b', 'c'} # => Set{'z', 'c'}``````

def add(object : T) #

Adds object to the set and returns `self`.

``````s = Set{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{1, 5}
s.size # => 2
s.clear
s.size # => 0``````

def clone #

Returns a new `Set` with all of the elements cloned.

def concat(elems) #

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

``````s = Set{1, 5}
s.concat [5, 5, 8, 9]
s.size # => 4``````

See also: `#|` to merge two sets and return a new one.

def delete(object) #

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

``````s = Set{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 #

Returns an iterator for each element of the set.

def each(&block) #

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

def empty? #

Returns `true` if the set is empty.

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

def hash(hasher) #

See `Object#hash(hasher)`

def includes?(object) #

Returns `true` if object exists in the set.

``````s = Set{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 pretty_print(pp) : Nil #

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{1, 5}.proper_subset? Set{1, 3, 5}    # => true
Set{1, 3, 5}.proper_subset? Set{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{1, 3, 5}.proper_superset? Set{1, 5}    # => true
Set{1, 3, 5}.proper_superset? Set{1, 3, 5} # => false``````

def size #

Returns the number of elements in the set.

``````s = Set{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{1, 5}.subset? Set{1, 3, 5}    # => true
Set{1, 3, 5}.subset? Set{1, 3, 5} # => true``````

def subtract(other : Enumerable) #

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

``````Set{'a', 'b', 'b', 'z'}.subtract Set{'a', 'b', 'c'} # => Set{'z'}
Set{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{1, 3, 5}.superset? Set{1, 5}    # => true
Set{1, 3, 5}.superset? Set{1, 3, 5} # => true``````

def to_a #

Returns the elements as an `Array`.

``Set{1, 5}.to_a # => [1,5]``

def to_json(json : JSON::Builder) #

def to_s(io) #

Writes a string representation of the set to io.

def to_yaml(yaml : YAML::Nodes::Builder) #

def |(other : Set(U)) forall U #

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

``````Set{1, 1, 3, 5} | Set{1, 2, 3}               # => Set{1, 3, 5, 2}
Set{'a', 'b', 'b', 'z'} | Set{'a', 'b', 'c'} # => Set{'a', 'b', 'z', 'c'}``````

See also: `#concat` to add elements from a set to `self`.