Module: Hamster::Enumerable

Includes:
Enumerable
Included in:
Hash, Set, SortedSet, Vector
Defined in:
lib/hamster/enumerable.rb

Overview

Helper module for Hamster's sequential collections

Classes including Hamster::Enumerable must implement:

  • #each (just like ::Enumerable).
  • #select, which takes a block, and returns an instance of the same class with only the items for which the block returns a true value

Instance Method Summary collapse

Methods included from Enumerable

#to_list

Instance Method Details

#<=>(other) ⇒ Object

Compare with other, and return 0, 1, or -1 if it is (respectively) equal to, greater than, or less than this collection.


83
84
85
86
87
88
89
90
91
92
93
94
95
# File 'lib/hamster/enumerable.rb', line 83

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

#==(other) ⇒ Boolean

Return true if other contains the same elements, in the same order.


99
100
101
# File 'lib/hamster/enumerable.rb', line 99

def ==(other)
  self.eql?(other) || other.respond_to?(:to_ary) && to_ary.eql?(other.to_ary)
end

#compactObject

Return a new collection with all nil elements removed.


20
21
22
# File 'lib/hamster/enumerable.rb', line 20

def compact
  select { |item| !item.nil? }
end

#each_index(&block) ⇒ Object

Yield all integers from 0 up to, but not including, the number of items in this collection. For collections which provide indexed access, these are all the valid, non-negative indices into the collection.


35
36
37
38
39
# File 'lib/hamster/enumerable.rb', line 35

def each_index(&block)
  return enum_for(:each_index) unless block_given?
  0.upto(size-1, &block)
  self
end

#grep(pattern, &block) ⇒ Object

Search the collection for elements which are #=== to item. Yield them to the optional code block if provided, and return them as a new collection.


26
27
28
29
30
# File 'lib/hamster/enumerable.rb', line 26

def grep(pattern, &block)
  result = select { |item| pattern === item }
  result = result.map(&block) if block_given?
  result
end

#group_by(&block) ⇒ Object

Groups the collection into sub-collections by the result of yielding them to the block. Returns a Hash where the keys are return values from the block, and the values are sub-collections (of the same type as this one).


77
78
79
# File 'lib/hamster/enumerable.rb', line 77

def group_by(&block)
  group_by_with(self.class.empty, &block)
end

#inspectObject

Convert this collection to a programmer-readable String representation.


122
123
124
125
126
# File 'lib/hamster/enumerable.rb', line 122

def inspect
  result = "#{self.class}["
  each_with_index { |obj, i| result << ', ' if i > 0; result << obj.inspect }
  result << "]"
end

#join(separator = $,) ⇒ Object

Convert all the elements into strings and join them together, separated by separator. By default, the separator is $,, the global default string separator, which is normally nil.


106
107
108
109
110
111
112
113
114
# File 'lib/hamster/enumerable.rb', line 106

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

#partitionObject

Return 2 collections, the first containing all the elements for which the block evaluates to true, the second containing the rest.


53
54
55
56
57
# File 'lib/hamster/enumerable.rb', line 53

def partition
  return enum_for(:partition) if not block_given?
  a,b = super
  [self.class.new(a), self.class.new(b)].freeze
end

#productObject

Multiply all the items (presumably numeric) in this collection together.


42
43
44
# File 'lib/hamster/enumerable.rb', line 42

def product
  reduce(1, &:*)
end

#rejectObject Also known as: delete_if

Return a new collection with all the elements for which the block returns false.


13
14
15
16
# File 'lib/hamster/enumerable.rb', line 13

def reject
  return enum_for(:reject) if not block_given?
  select { |item| !yield(item) }
end

#sumObject

Add up all the items (presumably numeric) in this collection.


47
48
49
# File 'lib/hamster/enumerable.rb', line 47

def sum
  reduce(0, &:+)
end

#to_setObject

Convert this collection to a Set.


117
118
119
# File 'lib/hamster/enumerable.rb', line 117

def to_set
  Set.new(self)
end