W3cubDocs

/Crystal 0.31

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

Included Modules

Defined in:

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

Constructors

Instance Method Summary

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 = "", &block)
join(separator, io, &block)
join(separator, io)
join(separator = "") 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?
none?(pattern)
none?(&block) none?
, one?(&block)
one?(pattern)
one? one?
, partition(&block) partition, product(&block)
product(initial : Number, &block)
product
product(initial : Number) product
, reduce(memo, &block)
reduce(&block) reduce
, reduce?(&block) reduce?, reject(&block : T -> )
reject(type : U.class) forall U
reject(pattern) reject
, select(pattern)
select(type : U.class) forall U
select(&block : T -> ) 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, tally : Hash(T, Int32) tally, to_a to_a, to_h
to_h(&block : T -> Tuple(K, V)) forall K, V to_h
, to_set to_set, zip(*others : Indexable | Iterable | Iterator, &block)
zip(*others : Indexable | Iterable | Iterator) zip
, zip?(*others : Indexable | Iterable | Iterator, &block)
zip?(*others : Indexable | Iterable | Iterator) zip?

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 : IO) : Nil 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) : Nil
inspect : String 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 : String
to_s(io : IO) : Nil 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) : self
from_json(string_or_io) : self from_json
, from_yaml(string_or_io : String | IO) : self from_yaml

Constructor Detail

def self.new(ctx : YAML::ParseContext, node : YAML::Nodes::Node)Source

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

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

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

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)Source

def self.new(initial_capacity = nil)Source

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.

def self.new(ctx : YAML::ParseContext, node : YAML::Nodes::Node, &block)Source

Instance Method Detail

def &(other : Set)Source

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 : Set(U)) forall USource

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}

def -(other : Enumerable)Source

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)Source

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)Source

Alias for #add

def ==(other : Set)Source

Returns true if both sets have the same elements.

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

def ===(object : T)Source

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 USource

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 USource

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)Source

Adds object to the set and returns self.

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

def add?(object : T)Source

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

def clearSource

Removes all elements in the set, and returns self.

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

def cloneSource

Returns a new Set with all of the elements cloned.

def concat(elems)Source

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)Source

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 dupSource

Returns a new Set with all of the same elements.

def each(&block)Source

Yields each element of the set, and returns self.

def eachSource

Returns an iterator for each element of the set.

def empty?Source

Returns true if the set is empty.

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

def hash(hasher)Source

def includes?(object)Source

Returns true if object exists in the set.

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

def inspect(io : IO) : NilSource

Alias of #to_s.

def intersects?(other : Set)Source

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) : NilSource

def proper_subset?(other : Set)Source

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)Source

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 sizeSource

Returns the number of elements in the set.

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

def subset?(other : Set)Source

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)Source

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)Source

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_aSource

Returns the elements as an Array.

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

def to_json(json : JSON::Builder)Source

def to_s(io : IO) : NilSource

Writes a string representation of the set to io.

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

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

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.

© 2012–2019 Manas Technology Solutions.
Licensed under the Apache License, Version 2.0.
https://crystal-lang.org/api/0.31.1/Set.html