module Hamster::Enumerable

def <=>(other)

greater than, or less than this collection.
Compare with `other`, and return 0, 1, or -1 if it is (respectively) equal to, 
def <=>(other)
  return 0 if self.equal?(other)
  enum1, enum2 = self.to_enum, other.to_enum
  loop do
    item1 = enum1.next
    item2 = enum2.next
    comp  = (item1 <=> item2)
    return comp if comp != 0
  end
  size1, size2 = self.size, other.size
  return 0 if size1 == size2
  size1 > size2 ? 1 : -1
end

def ==(other)

Returns:
  • (Boolean) - 
def ==(other)
  self.eql?(other) || other.respond_to?(:to_ary) && to_ary.eql?(other.to_ary)
end

def compact

Return a new collection with all `nil` elements removed. 
def compact
  select { |item| !item.nil? }
end

def each_index(&block)

the valid, non-negative indices into the collection.
this collection. For collections which provide indexed access, these are all
Yield all integers from 0 up to, but not including, the number of items in 
def each_index(&block)
  return enum_for(:each_index) unless block_given?
  0.upto(size-1, &block)
  self
end

def grep(pattern, &block)

the optional code block if provided, and return them as a new collection.
Search the collection for elements which are `#===` to `item`. Yield them to 
def grep(pattern, &block)
  result = select { |item| pattern === item }
  result = result.map(&block) if block_given?
  result
end

def grep_v(pattern, &block)

collection.
them to the optional code block if provided, and return them as a new
Search the collection for elements which are not `#===` to `item`. Yield 
def grep_v(pattern, &block)
  result = select { |item| !(pattern === item) }
  result = result.map(&block) if block_given?
  result
end

def group_by(&block)

and the values are sub-collections (of the same type as this one).
the block. Returns a {Hash} where the keys are return values from the block,
Groups the collection into sub-collections by the result of yielding them to 
def group_by(&block)
  group_by_with(self.class.empty, &block)
end

def group_by_with(empty_group, &block)

with an added element.
`empty_group`, which should respond to `#add` by returning a new collection
and the values are sub-collections. All the sub-collections are built up from
the block. Returns a {Hash} where the keys are return values from the block,
Groups the collection into sub-collections by the result of yielding them to 
def group_by_with(empty_group, &block)
  block ||= lambda { |item| item }
  reduce(EmptyHash) do |hash, item|
    key = block.call(item)
    group = hash.get(key) || empty_group
    hash.put(key, group.add(item))
  end
end

def inspect

Convert this collection to a programmer-readable `String` representation. 
def inspect
  result = "#{self.class}["
  each_with_index { |obj, i| result << ', ' if i > 0; result << obj.inspect }
  result << "]"
end

def join(separator = $,)

separator, which is normally `nil`.
`separator`. By default, the `separator` is `$,`, the global default string
Convert all the elements into strings and join them together, separated by 
def join(separator = $,)
  result = ""
  if separator
    each_with_index { |obj, i| result << separator if i > 0; result << obj.to_s }
  else
    each { |obj| result << obj.to_s }
  end
  result
end

def partition

evaluates to true, the second containing the rest.
Return 2 collections, the first containing all the elements for which the block 
def partition
  return enum_for(:partition) if not block_given?
  a,b = super
  [self.class.new(a), self.class.new(b)].freeze
end

def pretty_print(pp)

Other tags:
    Private: - 
def pretty_print(pp)
  pp.group(1, "#{self.class}[", "]") do
    pp.breakable ''
    pp.seplist(self) { |obj| obj.pretty_print(pp) }
  end
end

def product

Multiply all the items (presumably numeric) in this collection together. 
def product
  reduce(1, &:*)
end

def reject

Return a new collection with all the elements for which the block returns false. 
def reject
  return enum_for(:reject) if not block_given?
  select { |item| !yield(item) }
end

def sort_by(&block)

Other tags:
    Private: - 
def sort_by(&block)
  result = to_a
  result.frozen? ? result.sort_by(&block) : result.sort_by!(&block)
end

def sum

Add up all the items (presumably numeric) in this collection. 
def sum
  reduce(0, &:+)
end

def to_set

Convert this collection to a {Set}. 
def to_set
  Set.new(self)
end