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.


92
93
94
95
96
97
98
99
100
101
102
103
104
# File 'lib/hamster/enumerable.rb', line 92

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.

Returns:

  • (Boolean)

108
109
110
# File 'lib/hamster/enumerable.rb', line 108

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.


44
45
46
47
48
# File 'lib/hamster/enumerable.rb', line 44

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

#grep_v(pattern, &block) ⇒ Object

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


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

def grep_v(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).


86
87
88
# File 'lib/hamster/enumerable.rb', line 86

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

#inspectObject

Convert this collection to a programmer-readable `String` representation.


131
132
133
134
135
# File 'lib/hamster/enumerable.rb', line 131

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


115
116
117
118
119
120
121
122
123
# File 'lib/hamster/enumerable.rb', line 115

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.


62
63
64
65
66
# File 'lib/hamster/enumerable.rb', line 62

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

#pretty_print(pp) ⇒ Object


138
139
140
141
142
143
# File 'lib/hamster/enumerable.rb', line 138

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

#productObject

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


51
52
53
# File 'lib/hamster/enumerable.rb', line 51

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

#sort_by(&block) ⇒ Object

Rubinius implements Enumerable#sort_by using Enumerable#map Because we do our own, custom implementations of #map, that doesn't work well


154
155
156
157
# File 'lib/hamster/enumerable.rb', line 154

def sort_by(&block)
  result = to_a
  result.frozen? ? result.sort_by(&block) : result.sort_by!(&block)
end

#sumObject

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


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

def sum
  reduce(0, &:+)
end

#to_setObject

Convert this collection to a Set.


126
127
128
# File 'lib/hamster/enumerable.rb', line 126

def to_set
  Set.new(self)
end