Module: Elixir::Enum

Defined in:
lib/elixir/enum.rb

Class Method Summary collapse

Class Method Details

.all?(collection, &block) ⇒ Boolean

Returns:

  • (Boolean) 


5
6
7
 
# File 'lib/elixir/enum.rb', line 5

def all? collection, &block
  collection.all? &block
end

.any?(collection, &block) ⇒ Boolean

Returns:

  • (Boolean) 


9
10
11
 
# File 'lib/elixir/enum.rb', line 9

def any? collection, &block
  collection.any? &block
end

.at(collection, index, default = nil) ⇒ Object 



13
14
15
 
# File 'lib/elixir/enum.rb', line 13

def at collection, index, default = nil
  collection.first(index.next)[index] || default
end

.chunk(collection, n, step: nil, pad: nil) ⇒ Object 



17
18
 
# File 'lib/elixir/enum.rb', line 17

def chunk collection, n, step: nil, pad: nil
end

.chunk_by(collection, &block) ⇒ Object 



20
21
22
 
# File 'lib/elixir/enum.rb', line 20

def chunk_by collection, &block
  collection.chunk(&block).map(&:last).to_a
end

.concat(*collections) ⇒ Object 



24
25
26
 
# File 'lib/elixir/enum.rb', line 24

def concat *collections
  collections.inject :concat
end

.count(collection, &block) ⇒ Object 



28
29
30
 
# File 'lib/elixir/enum.rb', line 28

def count collection, &block
  collection.count &block
end

.drop(collection, count) ⇒ Object 



32
33
34
 
# File 'lib/elixir/enum.rb', line 32

def drop collection, count
  collection.drop count
end

.drop_while(collection, &block) ⇒ Object 



36
37
38
 
# File 'lib/elixir/enum.rb', line 36

def drop_while collection, &block
  collection.drop_while &block
end

.empty?(collection) ⇒ Boolean

Returns:

  • (Boolean) 


40
41
42
 
# File 'lib/elixir/enum.rb', line 40

def empty? collection
  collection.empty?
end

.fetch(collection, n) ⇒ Object 



44
45
 
# File 'lib/elixir/enum.rb', line 44

def fetch collection, n
end

.fetch!(collection, n) ⇒ Object 



47
48
 
# File 'lib/elixir/enum.rb', line 47

def fetch! collection, n
end

.filter(collection, &block) ⇒ Object 



50
51
52
 
# File 'lib/elixir/enum.rb', line 50

def filter collection, &block
  collection.select &block
end

.filter_map(collection, filter, mapper) ⇒ Object 



54
55
 
# File 'lib/elixir/enum.rb', line 54

def filter_map collection, filter, mapper
end

.find(collection, ifnone = nil, &block) ⇒ Object 



57
58
59
 
# File 'lib/elixir/enum.rb', line 57

def find collection, ifnone = nil, &block
  collection.find ifnone, &block
end

.find_index(collection, &block) ⇒ Object 



61
62
 
# File 'lib/elixir/enum.rb', line 61

def find_index collection, &block
end

.find_value(collection, ifnone = nil, &block) ⇒ Object 



64
65
 
# File 'lib/elixir/enum.rb', line 64

def find_value collection, ifnone = nil, &block
end

.flat_map(collection, &block) ⇒ Object 



67
68
69
 
# File 'lib/elixir/enum.rb', line 67

def flat_map collection, &block
  collection.flat_map &block
end

.flat_map_reduce(collection, acc, &block) ⇒ Object 



71
72
 
# File 'lib/elixir/enum.rb', line 71

def flat_map_reduce collection, acc, &block
end

.group_by(collection, dict = {}, &block) ⇒ Object 



74
75
 
# File 'lib/elixir/enum.rb', line 74

def group_by collection, dict = {}, &block
end

.intersperse(collection, element) ⇒ Object 



77
78
 
# File 'lib/elixir/enum.rb', line 77

def intersperse collection, element
end

.into(collection, list, transform = nil) ⇒ Object 



80
81
 
# File 'lib/elixir/enum.rb', line 80

def into collection, list, transform = nil
end

.join(collection, joiner = '') ⇒ Object 



83
84
85
 
# File 'lib/elixir/enum.rb', line 83

def join collection, joiner = ''
  collection.join joiner
end

.map(collection, &block) ⇒ Object 



87
88
89
 
# File 'lib/elixir/enum.rb', line 87

def map collection, &block
  collection.map &block
end

.map_join(collection, joiner = '', &block) ⇒ Object 



91
92
 
# File 'lib/elixir/enum.rb', line 91

def map_join collection, joiner = '', &block
end

.map_reduce(collection, acc, &block) ⇒ Object 



94
95
 
# File 'lib/elixir/enum.rb', line 94

def map_reduce collection, acc, &block
end

.max(collection) ⇒ Object 



97
98
99
 
# File 'lib/elixir/enum.rb', line 97

def max collection
  collection.max
end

.max_by(collection, &block) ⇒ Object 



101
102
 
# File 'lib/elixir/enum.rb', line 101

def max_by collection, &block
end

.member?(collection, value) ⇒ Boolean

Returns:

  • (Boolean) 


104
105
106
 
# File 'lib/elixir/enum.rb', line 104

def member? collection, value
  collection.member? value
end

.min(collection) ⇒ Object 



108
109
110
 
# File 'lib/elixir/enum.rb', line 108

def min collection
  collection.min
end

.min_by(collection, &block) ⇒ Object 



112
113
114
 
# File 'lib/elixir/enum.rb', line 112

def min_by collection, &block
  collection.min_by &block
end

.partition(collection, &block) ⇒ Object 



116
117
118
 
# File 'lib/elixir/enum.rb', line 116

def partition collection, &block
  collection.partition &block
end

.reduce(collection, acc = nil, &block) ⇒ Object 



120
121
122
 
# File 'lib/elixir/enum.rb', line 120

def reduce collection, acc = nil, &block
  collection.reduce acc, &block
end

.reject(collection, &block) ⇒ Object 



124
125
126
 
# File 'lib/elixir/enum.rb', line 124

def reject collection, &block
  collection.reject &block
end

.reverse(collection, tail = nil) ⇒ Object 



128
129
130
131
132
133
134
 
# File 'lib/elixir/enum.rb', line 128

def reverse collection, tail = nil
  if tail
    collection.reverse << tail
  else
    collection.reverse
  end
end

.scan(collection, acc = 0, &block) ⇒ Object 



136
137
 
# File 'lib/elixir/enum.rb', line 136

def scan collection, acc = 0, &block
end

.shuffle(collection) ⇒ Object 



139
140
141
 
# File 'lib/elixir/enum.rb', line 139

def shuffle collection
  collection.shuffle
end

.slice(collection, x, count = nil) ⇒ Object 



143
144
 
# File 'lib/elixir/enum.rb', line 143

def slice collection, x, count = nil
end

.sort(collection, &block) ⇒ Object 



146
147
148
 
# File 'lib/elixir/enum.rb', line 146

def sort collection, &block
  collection.sort &block
end

.sort_by(collection, mapper, sorter = nil) ⇒ Object 



150
151
 
# File 'lib/elixir/enum.rb', line 150

def sort_by collection, mapper, sorter = nil
end

.split(collection, count) ⇒ Object 



153
154
155
 
# File 'lib/elixir/enum.rb', line 153

def split collection, count
  
end

.split_while(collection, &block) ⇒ Object 



157
158
 
# File 'lib/elixir/enum.rb', line 157

def split_while collection, &block
end

.sum(collection) ⇒ Object 



160
161
162
 
# File 'lib/elixir/enum.rb', line 160

def sum collection
  collection.inject :+
end

.take(collection, count) ⇒ Object 



164
165
166
 
# File 'lib/elixir/enum.rb', line 164

def take collection, count
  collection.take count
end

.take_every(collection, nth) ⇒ Object 



168
169
170
 
# File 'lib/elixir/enum.rb', line 168

def take_every collection, nth
  collection.step by: nth
end

.take_while(collection, &block) ⇒ Object 



172
173
 
# File 'lib/elixir/enum.rb', line 172

def take_while collection, &block
end

.to_list(collection) ⇒ Object 



175
176
177
 
# File 'lib/elixir/enum.rb', line 175

def to_list collection
  collection.to_a
end

.uniq(collection, &block) ⇒ Object 



179
180
181
 
# File 'lib/elixir/enum.rb', line 179

def uniq collection, &block
  collection.uniq &block
end

.with_index(collection) ⇒ Object 



183
184
185
 
# File 'lib/elixir/enum.rb', line 183

def with_index collection
  collection.each_with_index.to_a
end

.zip(collection1, collection2) ⇒ Object 



187
188
189
 
# File 'lib/elixir/enum.rb', line 187

def zip collection1, collection2
  collection1.zip collection2
end