struct

Set(T)

Inherits Iterable / Enumerable / Struct / Value / Object

Set implements a collection of 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.
Enumeration follows the order that the elements were inserted.
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_of? s2 # => false
s2.subset_of? s1 # => true

Constructors

additive_identity

Returns the additive identity of this type.

This is an empty set.

Source

new(ctx : YAML::ParseContext, node : YAML::Nodes::Node)

Source

new(other : Indexable(T))

Optimized version of new used when other is also an Indexable

Source

new(enumerable : Enumerable(T))

Creates a new set from the elements in enumerable.

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

Source

new(pull : JSON::PullParser)

Source

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.

Source

new(ctx : YAML::ParseContext, node : YAML::Nodes::Node, &)

Source

Instance methods

&(other : Set) : Set(T)

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'}

Source

+(other : Set(U)) : Set(T | U) forall U

Addition: returns a new set containing the unique elements from both sets.

Set{1, 1, 2, 3} + Set{3, 4, 5} # => Set{1, 2, 3, 4, 5}

Source

-(other : Set) : Set(T)

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'}

Source

-(other : Enumerable) : Set(T)

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'}

Source

<<(object : T) : self

Alias for add

Source

==(other : Set) : Bool

Returns true if both sets have the same elements.

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

Source

===(object : T) : Bool

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#===.

Source

^(other : Set(U)) : Set(T | 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'}

Source

^(other : Enumerable(U)) : Set(T | 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'}

Source

|(other : Set(U)) : Set(T | 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.

Source

add(object : T) : self

Adds object to the set and returns self.

s = Set{1, 5}
s.includes? 8 # => false
s.add(8)
s.includes? 8 # => true

Source

add?(object : T) : Bool

Adds object to the set and returns true on success and false if the value was already in the set.

s = Set{1, 5}
s.add? 8 # => true
s.add? 8 # => false

Source

clear

Removes all elements in the set, and returns self.

s = Set{1, 5}
s.size # => 2
s.clear
s.size # => 0

Source

clone

Returns a new Set with all of the elements cloned.

Source

compare_by_identity

Makes this set compare objects using their object identity (object_id) for types that define such method (Reference types, but also structs that might wrap other Reference types and delegate the object_id method to them).

s = Set{"foo", "bar"}
s.includes?("fo" + "o") # => true

s.compare_by_identity
s.compare_by_identity?  # => true
s.includes?("fo" + "o") # => false # not the same String instance

Source

compare_by_identity?

Returns true if this Set is comparing objects by object_id.

See compare_by_identity.

Source

concat(elems) : self

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.

Source

delete(object) : Bool

Removes the object from the set and returns true if it was present, otherwise returns false.

s = Set{1, 5}
s.includes? 5 # => true
s.delete 5    # => true
s.includes? 5 # => false
s.delete 5    # => false

Source

dup

Returns a new Set with all of the same elements.

Source

each

Yields each element of the set, and returns nil.

Source

each

Returns an iterator for each element of the set.

Source

empty?

Returns true if the set is empty.

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

Source

hash(hasher)

See Object#hash(hasher)

Source

includes?(object) : Bool

Returns true if object exists in the set.

s = Set{1, 5}
s.includes? 5 # => true
s.includes? 9 # => false

Source

inspect(io : IO) : Nil

Alias of #to_s.

Source

intersects?(other : Set) : Bool

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

Source

map!

Replaces every element of the set with a value returned from the block, and returns self.

Source

pretty_print(pp) : Nil

Source

proper_subset_of?(other : Set) : Bool

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

Source

proper_superset_of?(other : Set) : Bool

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

The other must have 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_of? Set{1, 5}    # => true
Set{1, 3, 5}.proper_superset_of? Set{1, 3, 5} # => false

Source

rehash

Rebuilds the set based on the current elements.

When using mutable data types as elements, modifying an elements after it was inserted into the Set may lead to undefined behaviour. This method re-indexes the set using the current elements.

Source

reject!

Deletes every element of the set for which the block is truthy, and returns self.

Source

select!

Deletes every element of the set for which the block is falsey, and returns self.

Source

size

Returns the number of elements in the set.

s = Set{1, 5}
s.size # => 2

Source

subset_of?(other : Set) : Bool

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

Source

subtract(other : Enumerable) : self

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}

Source

superset_of?(other : Set) : Bool

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

Source

to_a

Returns the elements as an Array.

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

Source

to_a

Returns an Array with the results of running block against each element of the collection.

Set{1, 2, 3, 4, 5}.to_a { |i| i // 2 } # => [0, 1, 1, 2, 2]

Source

to_json(json : JSON::Builder) : Nil

Source

to_s(io : IO) : Nil

Writes a string representation of the set to io.

Source

to_yaml(yaml : YAML::Nodes::Builder) : Nil

Source