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#==
andObject#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
Included Modules
Defined in:
set.crjson/to_json.cr
yaml/to_yaml.cr
Constructors
- .new(ctx : YAML::ParseContext, node : YAML::Nodes::Node)
-
.new(other : Indexable(T))
Optimized version of
new
used when other is also anIndexable
-
.new(enumerable : Enumerable(T))
Creates a new set from the elements in enumerable.
- .new(pull : JSON::PullParser)
-
.new(initial_capacity = nil)
Creates a new, empty
Set
. - .new(ctx : YAML::ParseContext, node : YAML::Nodes::Node, &block)
Instance Method Summary
-
#&(other : Set)
Intersection: returns a new set containing elements common to both sets.
-
#-(other : Enumerable)
Difference: returns a new set containing elements in this set that are not present in the other enumerable.
-
#-(other : Set)
Difference: returns a new set containing elements in this set that are not present in the other.
-
#<<(object : T)
Alias for
#add
-
#==(other : Set)
Returns
true
if both sets have the same elements. -
#===(object : T)
Same as
#includes?
. -
#^(other : Enumerable(U)) forall U
Symmetric Difference: returns a new set
(self - other) | (other - self)
. -
#^(other : Set(U)) forall U
Symmetric Difference: returns a new set
(self - other) | (other - self)
. -
#add(object : T)
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. -
#concat(elems)
Adds
#each
element of elems to the set and returnsself
. -
#delete(object)
Removes the object from the set and returns
self
. -
#dup
Returns a new
Set
with all of the same elements. -
#each
Returns an iterator for each element of the set.
-
#each(&block)
Yields each element of the set, and returns
self
. -
#empty?
Returns
true
if the set is empty. - #hash(hasher)
-
#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. - #pretty_print(pp) : Nil
-
#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(json : JSON::Builder)
-
#to_s(io)
Writes a string representation of the set to io.
- #to_yaml(yaml : YAML::Nodes::Builder)
-
#|(other : Set(U)) forall U
Union: returns a new set containing all unique elements from both sets.
Instance methods inherited from module Iterable(T)
chunk(reuse = false, &block : T -> U) forall U
chunk,
chunk_while(reuse : Bool | Array(T) = false, &block : T, T -> B) forall B
chunk_while,
cycle(n)cycle cycle, each each, each_cons(count : Int, reuse = false) each_cons, each_slice(count : Int, reuse = false) each_slice, each_with_index(offset = 0) each_with_index, each_with_object(obj) each_with_object, slice_after(reuse : Bool | Array(T) = false, &block : T -> B) forall B
slice_after(pattern, reuse : Bool | Array(T) = false) slice_after, slice_before(reuse : Bool | Array(T) = false, &block : T -> B) forall B
slice_before(pattern, reuse : Bool | Array(T) = false) slice_before, slice_when(reuse : Bool | Array(T) = false, &block : T, T -> B) forall B slice_when
Instance methods inherited from module Enumerable(T)
all?(&block)all?(pattern)
all? all?, any?(&block)
any?(pattern)
any? any?, chunks(&block : T -> U) forall U chunks, compact_map(&block) compact_map, count(item)
count(&block) count, cycle(&block)
cycle(n, &block) cycle, each(&block : T -> UNDERSCORE) each, each_cons(count : Int, reuse = false, &block) each_cons, each_slice(count : Int, reuse = false, &block) each_slice, each_with_index(offset = 0, &block) each_with_index, each_with_object(obj, &block) each_with_object, find(if_none = nil, &block) find, first(count : Int)
first first, first? first?, flat_map(&block : T -> Array(U) | Iterator(U) | U) forall U flat_map, grep(pattern) grep, group_by(&block : T -> U) forall U group_by, in_groups_of(size : Int, filled_up_with : U = nil) forall U
in_groups_of(size : Int, filled_up_with : U = nil, reuse = false, &block) forall U in_groups_of, includes?(obj) includes?, index(&block)
index(obj) index, index_by(&block : T -> U) forall U index_by, join(separator, io)
join(separator = "")
join(separator, io, &block)
join(separator = "", &block) join, map(&block : T -> U) forall U map, map_with_index(&block : T, Int32 -> U) forall U map_with_index, max max, max? max?, max_by(&block : T -> U) forall U max_by, max_by?(&block : T -> U) forall U max_by?, max_of(&block : T -> U) forall U max_of, max_of?(&block : T -> U) forall U max_of?, min min, min? min?, min_by(&block : T -> U) forall U min_by, min_by?(&block : T -> U) forall U min_by?, min_of(&block : T -> U) forall U min_of, min_of?(&block : T -> U) forall U min_of?, minmax minmax, minmax? minmax?, minmax_by(&block : T -> U) forall U minmax_by, minmax_by?(&block : T -> U) forall U minmax_by?, minmax_of(&block : T -> U) forall U minmax_of, minmax_of?(&block : T -> U) forall U minmax_of?, none?(&block)
none?(pattern)
none? none?, one?(&block)
one?(pattern)
one? one?, partition(&block) partition, product
product(initial : Number, &block)
product(&block)
product(initial : Number) product, reduce(memo, &block)
reduce(&block) reduce, reject(&block : T -> )
reject(type : U.class) forall U
reject(pattern) reject, select(type : U.class) forall U
select(&block : T -> )
select(pattern) select, size size, skip(count : Int) skip, skip_while(&block) skip_while, sum(initial)
sum
sum(initial, &block)
sum(&block) sum, take_while(&block) take_while, to_a to_a, to_h
to_h(&block : T -> Tuple(K, V)) forall K, V to_h, to_set to_set
Instance methods inherited from struct Struct
==(other) : Bool
==,
hash(hasher)
hash,
inspect(io : IO) : Nil
inspect,
pretty_print(pp) : Nil
pretty_print,
to_s(io)
to_s
Instance methods inherited from struct Value
==(other : JSON::Any)==(other : YAML::Any)
==(other) ==, dup dup
Instance methods inherited from class Object
!=(other)
!=,
!~(other)
!~,
==(other)
==,
===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, class class, dup dup, hash(hasher)
hash hash, inspect(io : IO)
inspect inspect, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s
to_s(io : IO) to_s, to_yaml(io : IO)
to_yaml to_yaml, try(&block) try, unsafe_as(type : T.class) forall T unsafe_as
Constructor methods inherited from class Object
from_json(string_or_io, root : String) : selffrom_json(string_or_io) : self from_json, from_yaml(string_or_io : String | IO) : self from_yaml
Constructor Detail
Optimized version of new
used when other is also an Indexable
Creates a new set from the elements in enumerable.
a = [1, 3, 5]
s = Set.new a
s.empty? # => false
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
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'}
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'}
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'}
Returns true
if both sets have the same elements.
Set{1, 5} == Set{1, 5} # => true
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#===
.
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'}
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'}
Adds object to the set and returns self
.
s = Set{1, 5}
s.includes? 8 # => false
s << 8
s.includes? 8 # => true
Removes all elements in the set, and returns self
.
s = Set{1, 5}
s.size # => 2
s.clear
s.size # => 0
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.
Removes the object from the set and returns self
.
s = Set{1, 5}
s.includes? 5 # => true
s.delete 5
s.includes? 5 # => false
Returns true
if the set is empty.
s = Set(Int32).new
s.empty? # => true
s << 3
s.empty? # => false
Returns true
if object exists in the set.
s = Set{1, 5}
s.includes? 5 # => true
s.includes? 9 # => false
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
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
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
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
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}
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
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
.