класс Set

Родитель:: Объект
Включенные модули:: Enumerable

Эта библиотека предоставляет класс Set, который работает с коллекцией неупорядоченных значений без дублирования. Это гибрид интуитивно понятных средств взаимодействия массива и быстрого поиска хэша.

Метод to_set добавлен в Enumerable для удобства.

Set реализует коллекцию неупорядоченных значений без дублирования. Это гибрид интуитивно понятных средств взаимодействия массива и быстрого поиска хэша.

Set легко использовать с объектами Enumerable (реализующими each). Большинство методов инициализации и бинарных операторов принимают универсальные объекты Enumerable помимо множеств и массивов. Объект Enumerable может быть преобразован в Set с помощью метода to_set.

Set использует Hash в качестве хранилища, поэтому необходимо учитывать следующие моменты:

Равенство элементов определяется в соответствии с Object#eql? и Object#hash. Используйте Set#compare_by_identity, чтобы множество сравнивало элементы по их идентичности.
Set предполагает, что идентичность каждого элемента не меняется во время хранения. Изменение элемента множества приведет к тому, что множество станет ненадежным.
При хранении строки вместо неё хранится замороженная копия, если исходная строка не заморожена.

Сравнение

Операторы сравнения <, >, <=, и >= реализованы как сокращения для методов {proper_,}{subset?,superset?}. Оператор <=> отражает этот порядок или возвращает nil для множеств, у которых оба имеют отдельные элементы (например, {x, y} против {x, z}).

Пример

require 'set'
s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
s1 == s2                              #=> true
s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
s1.subset?(s2)                        #=> false
s2.subset?(s1)                        #=> true

Контакты

Акинори Муша <knu@iDaemons.org> (текущий основной разработчик)

Что здесь есть

Сначала то, что есть в другом месте. Класс Set:

Наследуется от класса Объект.
Включает модуль Enumerable, который предоставляет десятки дополнительных методов.

В частности, у класса Set нет многих собственных методов для извлечения или итерации. Вместо этого он полагается на методы из Enumerable.

Здесь класс Set предоставляет методы, полезные для:

Создание множества
Операции со множествами
Сравнение
Запросы
Назначение
Удаление
Преобразование
Итерация
И многое другое…

Методы для создания множества

::[] - Возвращает новое множество, содержащее заданные объекты.
::new - Возвращает новое множество, содержащее заданные объекты (если блок не указан) или значения, возвращаемые вызываемым блоком (если блок указан).

Методы для операций со множествами

| (алиас union и +) - Возвращает новое множество, содержащее все элементы из self и все элементы из заданного перечисляемого объекта (без дублирования).
& (алиас intersection) - Возвращает новое множество, содержащее все элементы, общие для self и заданного перечисляемого объекта.
- (алиас difference) - Возвращает копию self со всеми элементами из заданного перечисляемого объекта, удалёнными.
^ - Возвращает новое множество, содержащее все элементы из self и заданного перечисляемого объекта, за исключением общих.

Методы для сравнения

<=> - Возвращает -1, 0 или 1, в зависимости от того, является ли self меньше, равно или больше заданного объекта.
== - Возвращает, равны ли self и заданный перечисляемый объект, как определено методом Object#eql?.
compare_by_identity? - Возвращает, учитывает ли множество только идентичность при сравнении элементов.

Методы для запроса

length (алиас size) - Возвращает количество элементов.
empty? - Возвращает, пусто ли множество.
include? (алиас member? и ===) - Возвращает, содержится ли заданный объект в множестве.
subset? (алиас <=) - Возвращает, является ли заданный объект подмножеством множества.
proper_subset? (алиас <) - Возвращает, является ли заданный перечисляемый объект истинным подмножеством множества.
superset? (алиас <=]) - Возвращает, является ли заданный перечисляемый объект надмножеством множества.
proper_superset? (алиас >) - Возвращает, является ли заданный перечисляемый объект истинным надмножеством множества.
disjoint? - Возвращает true если у множества и заданного перечисляемого объекта нет общих элементов, false в противном случае.
intersect? - Возвращает true если у множества и заданного перечисляемого объекта есть общие элементы, false в противном случае.
compare_by_identity? - Возвращает, учитывает ли множество только идентичность при сравнении элементов.

Методы для назначения

add (алиас <<) - Добавляет заданный объект в множество; возвращает self.
add? - Если заданный объект не является элементом множества, добавляет его и возвращает self; в противном случае возвращает nil.
merge - Добавляет каждый заданный объект в множество; возвращает self.
replace - Заменяет содержимое множества содержимым заданного перечисляемого объекта.

Методы для удаления

clear - Удаляет все элементы из множества; возвращает self.
delete - Удаляет заданный объект из множества; возвращает self.
delete? - Если заданный объект является элементом множества, удаляет его и возвращает self; в противном случае возвращает nil.
subtract - Удаляет каждый заданный объект из множества; возвращает self.
delete_if - Удаляет элементы, указанные заданным блоком.
select! (алиас filter!) - Удаляет элементы, не указанные заданным блоком.
keep_if - Удаляет элементы, не указанные заданным блоком.
reject! Удаляет элементы, указанные заданным блоком.

Методы для преобразования

END_OF_DOCUMENT_MARKER

classify - Возвращает хеш, классифицирующий элементы, как определено заданным блоком.
collect! (алиас map!) - Заменяет каждый элемент значением, возвращаемым блоком.
divide - Возвращает хеш, классифицирующий элементы, как определено заданным блоком; отличается от classify тем, что блок может принимать один или два аргумента.
flatten - Возвращает новый набор, являющийся рекурсивным разворачиванием self. flatten! - Заменяет каждый вложенный набор в self элементами из этого набора.
inspect (алиас to_s) - Возвращает строку, отображающую элементы.
join - Возвращает строку, содержащую все элементы, преобразованные в строки по мере необходимости, соединенные заданным разделителем записей.
to_a - Возвращает массив, содержащий все элементы набора.
to_set - Возвращает self при отсутствии аргументов и блока; при наличии блока возвращает новый набор, состоящий из значений, возвращаемых блоком.

Методы для итерации

each - Вызывает блок с каждым последующим элементом; возвращает self.

Другие методы

reset - Сбрасывает внутреннее состояние; полезно, если объект был изменен во время обращения к элементу в наборе.

Методы публичного класса

[](*ary) Показать исходный код

# File lib/set.rb, line 230
def self.[](*ary)
  new(ary)
end

Создает новый набор, содержащий указанные объекты.

Set[1, 2]                   # => #<Set: {1, 2}>
Set[1, 2, 1]                # => #<Set: {1, 2}>
Set[1, 'c', :s]             # => #<Set: {1, "c", :s}>

json_create(object) Показать исходный код

# File ext/json/lib/json/add/set.rb, line 10
def self.json_create(object)
  new object['a']
end

Импортирует JSON объект, закодированный с помощью Marshal.

Метод, используемый для поддержки JSON кодирования.

new(enum = nil) { |o| ... } Показать исходный код

# File lib/set.rb, line 245
def initialize(enum = nil, &block) # :yields: o
  @hash ||= Hash.new(false)

  enum.nil? and return

  if block
    do_with_enum(enum) { |o| add(block[o]) }
  else
    merge(enum)
  end
end

Создает новый набор, содержащий элементы заданного объекта перечисления.

Если задан блок, элементы перечисления предварительно обрабатываются с помощью заданного блока.

Set.new([1, 2])                       #=> #<Set: {1, 2}>
Set.new([1, 2, 1])                    #=> #<Set: {1, 2}>
Set.new([1, 'c', :s])                 #=> #<Set: {1, "c", :s}>
Set.new(1..5)                         #=> #<Set: {1, 2, 3, 4, 5}>
Set.new([1, 2, 3]) { |x| x * x }      #=> #<Set: {1, 4, 9}>

Методы публичного экземпляра

&(перечисление) Показать исходный код

# File lib/set.rb, line 648
def &(enum)
  n = self.class.new
  if enum.is_a?(Set)
    if enum.size > size
      each { |o| n.add(o) if enum.include?(o) }
    else
      enum.each { |o| n.add(o) if include?(o) }
    end
  else
    do_with_enum(enum) { |o| n.add(o) if include?(o) }
  end
  n
end

Возвращает новый набор, содержащий элементы, общие для набора и данного перечисляемого объекта.

Set[1, 3, 5] & Set[3, 2, 1]             #=> #<Set: {3, 1}>
Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> #<Set: {"a", "b"}>

Также известен как: intersection

+(перечисление)

Псевдоним для: |

-(перечисление) Показать исходный код

# File lib/set.rb, line 638
def -(enum)
  dup.subtract(enum)
end

Возвращает новый набор, созданный путём дублирования набора, удаляя каждый элемент, который появляется в данном перечисляемом объекте.

Set[1, 3, 5] - Set[1, 5]                #=> #<Set: {3}>
Set['a', 'b', 'z'] - ['a', 'c']         #=> #<Set: {"b", "z"}>

Также известен как: difference

<(множество)

Псевдоним для: proper_subset?

<<(o)

Псевдоним для: add

<=(множество)

Псевдоним для: subset?

<=>(множество) Показать исходный код

# File lib/set.rb, line 463
def <=>(set)
  return unless set.is_a?(Set)

  case size <=> set.size
  when -1 then -1 if proper_subset?(set)
  when +1 then +1 if proper_superset?(set)
  else 0 if self.==(set)
  end
end

Возвращает 0, если наборы равны, -1 / +1, если набор является правильным подмножеством / надмножеством данного набора или nil, если у обоих есть уникальные элементы.

==(другой) Показать исходный код

# File lib/set.rb, line 682
def ==(other)
  if self.equal?(other)
    true
  elsif other.instance_of?(self.class)
    @hash == other.instance_variable_get(:@hash)
  elsif other.is_a?(Set) && self.size == other.size
    other.all? { |o| @hash.include?(o) }
  else
    false
  end
end

Возвращает true, если два набора равны. Равенство каждой пары элементов определяется в соответствии с Object#eql?.

Set[1, 2] == Set[2, 1]                       #=> true
Set[1, 3, 5] == Set[1, 5]                    #=> false
Set['a', 'b', 'c'] == Set['a', 'c', 'b']     #=> true
Set['a', 'b', 'c'] == ['a', 'c', 'b']        #=> false

===(o)

Возвращает true, если заданный объект является членом набора, и false в противном случае.

Используется в операторах case:

require 'set'

case :apple
when Set[:potato, :carrot]
  "vegetable"
when Set[:apple, :banana]
  "fruit"
end
# => "fruit"

Или самостоятельно:

Set[1, 2, 3] === 2   #=> true
Set[1, 2, 3] === 4   #=> false

Псевдоним для: include?

>(множество)

Псевдоним для: proper_superset?

>=(множество)

Псевдоним для: superset?

^(перечисление) Показать исходный код

# File lib/set.rb, line 669
def ^(enum)
  n = Set.new(enum)
  each { |o| n.add(o) unless n.delete?(o) }
  n
end

Возвращает новый набор, содержащий элементы, уникальные для набора и заданного перечисляемого объекта. (set ^ enum) эквивалентно ((set | enum) - (set & enum)).

Set[1, 2] ^ Set[2, 3]                   #=> #<Set: {3, 1}>
Set[1, 'b', 'c'] ^ ['b', 'd']           #=> #<Set: {"d", 1, "c"}>

add(o) Показать исходный код

# File lib/set.rb, line 521
def add(o)
  @hash[o] = true
  self
end

Добавляет заданный объект в набор и возвращает self. Используйте merge для добавления сразу нескольких элементов.

Set[1, 2].add(3)                    #=> #<Set: {1, 2, 3}>
Set[1, 2].add([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
Set[1, 2].add(2)                    #=> #<Set: {1, 2}>

Также известен как: <<

add?(o) Показать исходный код

# File lib/set.rb, line 533
def add?(o)
  add(o) unless include?(o)
end

Добавляет заданный объект в набор и возвращает self. Если объект уже есть в наборе, возвращает nil.

Set[1, 2].add?(3)                    #=> #<Set: {1, 2, 3}>
Set[1, 2].add?([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
Set[1, 2].add?(2)                    #=> nil

as_json(*) Показать исходный код

# File ext/json/lib/json/add/set.rb, line 17
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'a'            => to_a,
  }
end

Marshal объект в JSON.

Метод используется для поддержки JSON сериализации.

classify() { |o| ... } Показать исходный код

# File lib/set.rb, line 751
def classify # :yields: o
  block_given? or return enum_for(__method__) { size }

  h = {}

  each { |i|
    (h[yield(i)] ||= self.class.new).add(i)
  }

  h
end

Классифицирует набор по возвращаемому значению данного блока и возвращает хеш пар {значение => множество элементов}. Блок вызывается один раз для каждого элемента набора, передавая элемент в качестве параметра.

require 'set'
files = Set.new(Dir.glob("*.rb"))
hash = files.classify { |f| File.mtime(f).year }
hash       #=> {2000=>#<Set: {"a.rb", "b.rb"}>,
           #    2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
           #    2002=>#<Set: {"f.rb"}>}

Возвращает перечислитель, если блок не задан.

clear() Показать исходный код

# File lib/set.rb, line 326
def clear
  @hash.clear
  self
end

Удаляет все элементы и возвращает self.

set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
set.clear                         #=> #<Set: {}>
set                               #=> #<Set: {}>

collect!() { |o| ... } Показать исходный код

# File lib/set.rb, line 574
def collect!
  block_given? or return enum_for(__method__) { size }
  set = self.class.new
  each { |o| set << yield(o) }
  replace(set)
end

Заменяет элементы на возвращаемые collect(). Возвращает перечислитель, если блок не задан.

Также известен как: map!

compare_by_identity() Показать исходный код

# File lib/set.rb, line 259
def compare_by_identity
  if @hash.respond_to?(:compare_by_identity)
    @hash.compare_by_identity
    self
  else
    raise NotImplementedError, "#{self.class.name}\##{__method__} is not implemented"
  end
end

Заставляет набор сравнивать свои элементы по их идентификаторам и возвращает self. Этот метод может не поддерживаться всеми подклассами Set.

compare_by_identity?() Показать исходный код

# File lib/set.rb, line 270
def compare_by_identity?
  @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
end

Возвращает true, если набор будет сравнивать свои элементы по их идентификаторам. Также см. Set#compare_by_identity.

delete(o) Показать исходный код

# File lib/set.rb, line 539
def delete(o)
  @hash.delete(o)
  self
end

Удаляет заданный объект из набора и возвращает self. Используйте subtract для удаления сразу нескольких элементов.

delete?(o) Показать исходный код

# File lib/set.rb, line 546
def delete?(o)
  delete(o) if include?(o)
end

Удаляет заданный объект из набора и возвращает self. Если объект отсутствует в наборе, возвращает nil.

delete_if() { |o| ... } Показать исходный код

# File lib/set.rb, line 553
def delete_if
  block_given? or return enum_for(__method__) { size }
  # @hash.delete_if should be faster, but using it breaks the order
  # of enumeration in subclasses.
  select { |o| yield o }.each { |o| @hash.delete(o) }
  self
end

Удаляет все элементы набора, для которых блок возвращает true, и возвращает self. Возвращает перечислитель, если блок не задан.

difference(перечисление)

Псевдоним для: -

disjoint?(множество) Показать исходный код

# File lib/set.rb, line 502
def disjoint?(set)
  !intersect?(set)
end

Возвращает true, если у набора и данного перечисляемого объекта нет общих элементов. Этот метод является противоположностью intersect?.

Set[1, 2, 3].disjoint? Set[3, 4]   #=> false
Set[1, 2, 3].disjoint? Set[4, 5]   #=> true
Set[1, 2, 3].disjoint? [3, 4]      #=> false
Set[1, 2, 3].disjoint? 4..5        #=> true

END_OF_DOCUMENT_MARKER

divide(&func) Показать исходный код

# File lib/set.rb, line 779
def divide(&func)
  func or return enum_for(__method__) { size }

  if func.arity == 2
    require 'tsort'

    class << dig = {}         # :nodoc:
      include TSort

      alias tsort_each_node each_key
      def tsort_each_child(node, &block)
        fetch(node).each(&block)
      end
    end

    each { |u|
      dig[u] = a = []
      each{ |v| func.call(u, v) and a << v }
    }

    set = Set.new()
    dig.each_strongly_connected_component { |css|
      set.add(self.class.new(css))
    }
    set
  else
    Set.new(classify(&func).values)
  end
end

Делит множество на подмножества в соответствии с общностью, определённой заданным блоком.

Если арность блока равна 2, элементы o1 и o2 являются общими, если block.call(o1, o2) истинно. В противном случае, элементы o1 и o2 являются общими, если block.call(o1) == block.call(o2).

require 'set'
numbers = Set[1, 3, 4, 6, 9, 10, 11]
set = numbers.divide { |i,j| (i - j).abs == 1 }
set        #=> #<Set: {#<Set: {1}>,
           #           #<Set: {11, 9, 10}>,
           #           #<Set: {3, 4}>,
           #           #<Set: {6}>}>

Возвращает перечислитель, если блок не задан.

each(&block) Показать исходный код

# File lib/set.rb, line 509
def each(&block)
  block or return enum_for(__method__) { size }
  @hash.each_key(&block)
  self
end

Вызывает заданный блок один раз для каждого элемента в множестве, передавая элемент в качестве параметра. Возвращает перечислитель, если блок не задан.

empty?() Показать исходный код

# File lib/set.rb, line 317
def empty?
  @hash.empty?
end

Возвращает true, если множество не содержит элементов.

filter!(&block)

Эквивалентно Set#select!

Псевдоним для: select!

flatten() Показать исходный код

# File lib/set.rb, line 387
def flatten
  self.class.new.flatten_merge(self)
end

Возвращает новое множество, являющееся копией множества, рекурсивно выравнивающее каждое содержащее множество.

flatten!() Показать исходный код

# File lib/set.rb, line 393
def flatten!
  replace(flatten()) if any? { |e| e.is_a?(Set) }
end

Эквивалентно Set#flatten, но заменяет получателя результатом на месте. Возвращает nil, если изменений не произошло.

include?(o) Показать исходный код

# File lib/set.rb, line 403
def include?(o)
  @hash[o]
end

Возвращает true, если множество содержит заданный объект.

Обратите внимание, что include? и member? не проверяют равенство элементов по членству с помощью ==, как и другие Enumerables.

См. также Enumerable#include?

Также псевдонимом является: member?, ===

initialize_clone(orig, **options) Показать исходный код

# File lib/set.rb, line 293
def initialize_clone(orig, **options)
  super
  @hash = orig.instance_variable_get(:@hash).clone(**options)
end

Клонирует внутренний хэш.

Вызывает метод суперкласса

initialize_dup(orig) Показать исходный код

# File lib/set.rb, line 286
def initialize_dup(orig)
  super
  @hash = orig.instance_variable_get(:@hash).dup
end

Дублирует внутренний хэш.

Вызывает метод суперкласса

inspect() Показать исходный код

# File lib/set.rb, line 819
def inspect
  ids = (Thread.current[InspectKey] ||= [])

  if ids.include?(object_id)
    return sprintf('#<%s: {...}>', self.class.name)
  end

  ids << object_id
  begin
    return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
  ensure
    ids.pop
  end
end

Возвращает строку, содержащую удобочитаемое представление множества (“#<Множество: {элемент1, элемент2, …}>”).

Также псевдонимом является: to_s

intersect?(set) Показать исходный код

# File lib/set.rb, line 480
def intersect?(set)
  case set
  when Set
    if size < set.size
      any? { |o| set.include?(o) }
    else
      set.any? { |o| include?(o) }
    end
  when Enumerable
    set.any? { |o| include?(o) }
  else
    raise ArgumentError, "value must be enumerable"
  end
end

Возвращает true, если множество и заданный перечислитель имеют хотя бы один общий элемент.

Set[1, 2, 3].intersect? Set[4, 5]   #=> false
Set[1, 2, 3].intersect? Set[3, 4]   #=> true
Set[1, 2, 3].intersect? 4..5        #=> false
Set[1, 2, 3].intersect? [3, 4]      #=> true

intersection(enum)

Псевдоним для: &

join(separator=nil) Показать исходный код

# File lib/set.rb, line 811
def join(separator=nil)
  to_a.join(separator)
end

Возвращает строку, созданную путём преобразования каждого элемента множества в строку. См. также: Array#join

keep_if() { |o| ... } Показать исходный код

# File lib/set.rb, line 564
def keep_if
  block_given? or return enum_for(__method__) { size }
  # @hash.keep_if should be faster, but using it breaks the order of
  # enumeration in subclasses.
  reject { |o| yield o }.each { |o| @hash.delete(o) }
  self
end

Удаляет каждый элемент множества, для которого блок возвращает false, и возвращает self. Возвращает перечислитель, если блок не задан.

length()

Псевдоним для: size

map!()

Псевдоним для: collect!

member?(o)

Псевдоним для: include?

merge(enum) Показать исходный код

# File lib/set.rb, line 605
def merge(enum)
  if enum.instance_of?(self.class)
    @hash.update(enum.instance_variable_get(:@hash))
  else
    do_with_enum(enum) { |o| add(o) }
  end

  self
end

Объединяет элементы заданного перечислителя с множеством и возвращает self.

proper_subset?(set) Показать исходный код

# File lib/set.rb, line 448
def proper_subset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:<)
    @hash < set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size < set.size && all? { |o| set.include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

Возвращает true, если множество является истинным подмножеством заданного множества.

Также псевдонимом является: <

proper_superset?(set) Показать исходный код

# File lib/set.rb, line 422
def proper_superset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:>)
    @hash > set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size > set.size && set.all? { |o| include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

Возвращает true, если множество является истинным надмножеством заданного множества.

Также псевдонимом является: >

reject!(&block) Показать исходный код

# File lib/set.rb, line 584
def reject!(&block)
  block or return enum_for(__method__) { size }
  n = size
  delete_if(&block)
  self if size != n
end

Эквивалентно Set#delete_if, но возвращает nil, если изменений не произошло. Возвращает перечислитель, если блок не задан.

replace(enum) Показать исходный код

# File lib/set.rb, line 337
def replace(enum)
  if enum.instance_of?(self.class)
    @hash.replace(enum.instance_variable_get(:@hash))
    self
  else
    do_with_enum(enum)  # make sure enum is enumerable before calling clear
    clear
    merge(enum)
  end
end

Заменяет содержимое множества содержимым заданного перечислителя и возвращает self.

set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
set.replace([1, 2])               #=> #<Set: {1, 2}>
set                               #=> #<Set: {1, 2}>

reset() Показать исходный код

# File lib/set.rb, line 707
def reset
  if @hash.respond_to?(:rehash)
    @hash.rehash # This should perform frozenness check.
  else
    raise FrozenError, "can't modify frozen #{self.class.name}" if frozen?
  end
  self
end

Сбрасывает внутреннее состояние после модификации существующих элементов и возвращает self.

Элементы будут переиндексированы и дедублированы.

select!(&block) Показать исходный код

# File lib/set.rb, line 593
def select!(&block)
  block or return enum_for(__method__) { size }
  n = size
  keep_if(&block)
  self if size != n
end

Эквивалентно Set#keep_if, но возвращает nil, если изменений не произошло. Возвращает перечислитель, если блок не задан.

Также псевдонимом является: filter!

size() Показать исходный код

# File lib/set.rb, line 311
def size
  @hash.size
end

Возвращает количество элементов.

Также псевдонимом является: length

subset?(set) Показать исходный код

# File lib/set.rb, line 435
def subset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:<=)
    @hash <= set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size <= set.size && all? { |o| set.include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

Возвращает true, если множество является подмножеством заданного множества.

Также алиасировано как: <=

subtract(enum) Показать исходный код

# File lib/set.rb, line 617
def subtract(enum)
  do_with_enum(enum) { |o| delete(o) }
  self
end

Удаляет каждый элемент, присутствующий в заданном перечислимом объекте, и возвращает self.

superset?(set) Показать исходный код

# File lib/set.rb, line 409
def superset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:>=)
    @hash >= set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size >= set.size && set.all? { |o| include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

Возвращает true, если множество является надмножеством заданного множества.

Также алиасировано как: >=

to_a() Показать исходный код

# File lib/set.rb, line 352
def to_a
  @hash.keys
end

Преобразует множество в массив. Порядок элементов не определён.

Set[1, 2].to_a                    #=> [1, 2]
Set[1, 'c', :s].to_a              #=> [1, "c", :s]

to_json(*args) Показать исходный код

# File ext/json/lib/json/add/set.rb, line 25
def to_json(*args)
  as_json.to_json(*args)
end

возвращает значение JSON

to_s()

Псевдоним для: inspect

to_set(klass = Set, *args, &block) Показать исходный код

# File lib/set.rb, line 361
def to_set(klass = Set, *args, &block)
  return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
  klass.new(self, *args, &block)
end

Возвращает self, если аргументы не заданы. В противном случае, преобразует множество в другое с klass.new(self, *args, &block).

В подклассах, возвращает klass.new(self, *args, &block), если не переопределено.

union(enum)

Псевдоним для: |

|(enum) Показать исходный код

# File lib/set.rb, line 627
def |(enum)
  dup.merge(enum)
end

Возвращает новое множество, созданное путём объединения исходного множества и элементов перечислимого объекта.

Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>

Также алиасировано как: +, union

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.