Module: Hamster::Enumerable

Includes:
Enumerable
Included in:
Hash, List, 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.


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

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.


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

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.


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

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.


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

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.


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

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


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

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

#inspectObject

Convert this collection to a programmer-readable String representation.


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

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.


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

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.


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

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.


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

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.


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

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.


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

def sum
  reduce(0, &:+)
end

#to_setObject

Convert this collection to a Set.


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

def to_set
  Set.new(self)
end