Ruby

/*

* call-seq:

*

* Returns an array of every element in <i>enum</i> for which

* <code>Pattern === element</code>. If the optional <em>block</em> is

* (1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44]

* c = IO.constants

* c.grep(/SEEK/) #=> [:SEEK_SET, :SEEK_CUR, :SEEK_END]

* res #=> [0, 1, 2]

*

*/

/*

* call-seq:

*

* Returns the number of items in <i>enum</i>, where #size is called

* if it responds to it, otherwise the items are counted through

* given, counts the number of elements yielding a true value.

*

* ary = [1, 2, 4, 2]

*

*/

/*

* call-seq:

*

* Passes each entry in <i>enum</i> to <em>block</em>. Returns the

* first for which <em>block</em> is not false. If no

*

* If no block is given, an enumerator is returned instead.

*

*

*/

/*

* call-seq:

*

* Compares each entry in <i>enum</i> with <em>value</em> or passes

* to <em>block</em>. Returns the index for the first for which the

*

* If neither block nor argument is given, an enumerator is returned instead.

*

* (1..100).find_index(50) #=> 49

*

*/

/*

* call-seq:

*

* Returns an array containing all elements of <i>enum</i> for which

* <em>block</em> is not <code>false</code> (see also

* If no block is given, an enumerator is returned instead.

*

*

*

*/

/*

* call-seq:

*

* Returns an array for all elements of <i>enum</i> for which

* <em>block</em> is false (see also <code>Enumerable#find_all</code>).

*

* If no block is given, an enumerator is returned instead.

*

*

*/

/*

* call-seq:

*

* Returns a new array with the results of running <em>block</em> once

* for every element in <i>enum</i>.

*

* If no block is given, an enumerator is returned instead.

*

* (1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]

*

*/

/*

* call-seq:

*

* Returns a new array with the concatenated results of running

* <em>block</em> once for every element in <i>enum</i>.

*

* If no block is given, an enumerator is returned instead.

*

*

*/

/*

* call-seq:

*

* Returns an array containing the items in <i>enum</i>.

*

* call-seq:

* enum.inject(initial, sym) -> obj

* enum.inject(sym) -> obj

* enum.reduce(initial, sym) -> obj

* enum.reduce(sym) -> obj

*

* Combines all elements of <i>enum</i> by applying a binary

* operation, specified by a block or a symbol that names a

* Examples:

*

* # Sum some numbers

* # Same using a block and inject

* # Multiply some numbers

* # Same using a block

* # find the longest word

* longest = %w{ cat sheep bear }.inject do |memo,word|

* memo.length > word.length ? memo : word

* end

*

*/

static VALUE

/*

* call-seq:

*

* Returns two arrays, the first containing the elements of

* <i>enum</i> for which the block evaluates to true, the second

*

* If no block is given, an enumerator is returned instead.

*

*

*/

/*

* call-seq:

*

* Returns a hash, which keys are evaluated result from the

* block, and values are arrays of elements in <i>enum</i>

*

* If no block is given, an enumerator is returned instead.

*

*

*/

/*

* call-seq:

*

* Returns an array containing the items in <i>enum</i> sorted,

* either according to their own <code><=></code> method, or by using

* built-in Schwartzian Transform, useful when key computation or

* comparison is expensive.

*

*/

static VALUE

/*

* call-seq:

*

* Sorts <i>enum</i> using a set of keys generated by mapping the

* values in <i>enum</i> through the given block.

*

* If no block is given, an enumerator is returned instead.

*

* #=> ["fig", "pear", "apple"]

*

* The current implementation of <code>sort_by</code> generates an

*

* require 'benchmark'

*

*

* Benchmark.bm(10) do |b|

* b.report("Sort") { a.sort }

* end

*

* <em>produces:</em>

* using the basic <code>sort</code> method.

*

* files = Dir["*"]

* sorted #=> ["mon", "tues", "wed", "thurs"]

*

* This sort is inefficient: it generates two new <code>File</code>

*

* This is exactly what <code>sort_by</code> does internally.

*

* sorted #=> ["mon", "tues", "wed", "thurs"]

*/

/*

* call-seq:

*

* Passes each element of the collection to the given block. The method

* returns <code>true</code> if the block never returns

* <code>false</code> or <code>nil</code>. If the block is not given,

* <code>all?</code> will return <code>true</code> only if none of the

* collection members are <code>false</code> or <code>nil</code>.)

*

*

*/

/*

* call-seq:

*

* Passes each element of the collection to the given block. The method

* returns <code>true</code> if the block ever returns a value other

* than <code>false</code> or <code>nil</code>. If the block is not

* is <code>any?</code> will return <code>true</code> if at least one

* of the collection members is not <code>false</code> or

* <code>nil</code>.

*

*

*/

/*

* call-seq:

*

* Passes each element of the collection to the given block. The method

* returns <code>true</code> if the block returns <code>true</code>

* <code>true</code> only if exactly one of the collection members is

* true.

*

*

*/

/*

* call-seq:

*

* Passes each element of the collection to the given block. The method

* returns <code>true</code> if the block never returns <code>true</code>

* for all elements. If the block is not given, <code>none?</code> will return

* <code>true</code> only if none of the collection members is true.

*

*/

static VALUE

enum_none(VALUE obj)

/*

* call-seq:

*

* Returns the object in <i>enum</i> with the minimum value. The

* first form assumes all objects implement <code>Comparable</code>;

*

* a = %w(albatross dog horse)

* a.min #=> "albatross"

*/

static VALUE

/*

* call-seq:

*

* Returns the object in _enum_ with the maximum value. The

* first form assumes all objects implement <code>Comparable</code>;

*

* a = %w(albatross dog horse)

* a.max #=> "horse"

*/

static VALUE

/*

* call-seq:

*

* Returns two elements array which contains the minimum and the

* maximum value in the enumerable. The first form assumes all

*

* a = %w(albatross dog horse)

* a.minmax #=> ["albatross", "horse"]

*/

static VALUE

/*

* call-seq:

*

* Returns the object in <i>enum</i> that gives the minimum

* value from the given block.

* If no block is given, an enumerator is returned instead.

*

* a = %w(albatross dog horse)

*/

static VALUE

/*

* call-seq:

*

* Returns the object in <i>enum</i> that gives the maximum

* value from the given block.

* If no block is given, an enumerator is returned instead.

*

* a = %w(albatross dog horse)

*/

static VALUE

/*

* call-seq:

*

* Returns two elements array array containing the objects in

* <i>enum</i> that gives the minimum and maximum values respectively

* If no block is given, an enumerator is returned instead.

*

* a = %w(albatross dog horse)

*/

static VALUE

/*

* call-seq:

*

* Calls <em>block</em> with two arguments, the item and its index,

* for each item in <i>enum</i>. Given arguments are passed through

* If no block is given, an enumerator is returned instead.

*

* hash = Hash.new

* hash[item] = index

* }

* hash #=> {"cat"=>0, "dog"=>1, "wombat"=>2}

/*

* call-seq:

*

* Builds a temporary array and traverses that array in reverse order.

*

* If no block is given, an enumerator is returned instead.

*

*

* produces:

*

/*

* call-seq:

*

* Calls <i>block</i> once for each element in +self+, passing that

* element as a parameter, converting multiple values from yield to an

* yield

* end

* end

*

* produces:

*

/*

* call-seq:

*

* Iterates the given block for each slice of <n> elements. If no

* block is given, returns an enumerator.

*

* e.g.:

* # outputs below

* [1, 2, 3]

* [4, 5, 6]

/*

* call-seq:

* enum.each_cons(n) -> an_enumerator

*

* Iterates the given block for each array of consecutive <n>

* elements. If no block is given, returns an enumerator.

*

* e.g.:

* # outputs below

* [1, 2, 3]

* [2, 3, 4]

/*

* call-seq:

*

* Iterates the given block for each element with an arbitrary

* object given, and returns the initially given object.

* If no block is given, returns an enumerator.

*

* e.g.:

* #=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

*

*/

/*

* call-seq:

*

* Takes one element from <i>enum</i> and merges corresponding

* elements from each <i>args</i>. This generates a sequence of

/*

* call-seq:

*

* Passes elements to the block until the block returns +nil+ or +false+,

* then stops iterating and returns an array of all prior elements.

* If no block is given, an enumerator is returned instead.

*

* a = [1, 2, 3, 4, 5, 0]

*

*/

/*

* call-seq:

* enum.drop_while -> an_enumerator

*

* Drops elements up to, but not including, the first element for

* If no block is given, an enumerator is returned instead.

*

* a = [1, 2, 3, 4, 5, 0]

*

*/

/*

* call-seq:

* enum.cycle(n=nil) -> an_enumerator

*

* Calls <i>block</i> for each element of <i>enum</i> repeatedly _n_

* If no block is given, an enumerator is returned instead.

*

* a = ["a", "b", "c"]

*

*/

/*

* call-seq:

*

* Creates an enumerator for each chunked elements.

* The consecutive elements which have same block value are chunked.

* The result enumerator yields the block value and an array of chunked elements.

* So "each" method can be called as follows.

*

*

* For example, consecutive even numbers and odd numbers can be

* splitted as follows.

*

* n.even?

* p [even, ary]

* }

* #=> [false, [3, 1]]

* This method is especially useful for sorted series of elements.

* The following example counts words for each initial letter.

*

* }

* #=> ["\n", 1]

* # ["A", 1327]

* For example, the sequence of hyphens in svn log can be eliminated as follows.

*

* sep = "-"*72 + "\n"

* line != sep || nil

* pp lines

* }

* }

*

* paragraphs separated by empty lines can be parsed as follows.

*

* /\A\s*\z/ !~ line || nil

* pp lines

* }

*

* pass other lines, chunk can be used as follows.

*

* pat = /\A[A-Z][A-Za-z0-9_]+\#/

* if key != :_alone

* print lines.sort.join('')

* else

/*

* call-seq:

*

* Creates an enumerator for each chunked elements.

* The beginnings of chunks are defined by _pattern_ and the block.

* method.

* +each+ method can be called as follows.

*

*

* Other methods of Enumerator class and Enumerable module,

* such as map, etc., are also usable.

* follows.

*

* # iterate over ChangeLog entries.

* }

*

* # same as above. block is used instead of pattern argument.

* }

*

* "svn proplist -R" produces multiline output for each file.

* They can be chunked as follows:

*

* }

* #=> ["Properties on '.':\n", " svn:ignore\n", " svk:merge\n"]

* # ["Properties on 'goruby.c':\n", " svn:eol-style\n"]

*

* a = [0,2,3,4,6,7,9]

* prev = a[0]

* prev, prev2 = e, prev

* prev2 + 1 != e

* es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}"

* }.join(",")

* #=> "0,2-4,6,7,9"

* # this assumes all characters have same width.

* def wordwrap(words, maxwidth)

* # if cols is a local variable, 2nd "each" may start with non-zero cols.

* h[:cols] += 1 if h[:cols] != 0

* h[:cols] += w.length

* if maxwidth < h[:cols]

* text = (1..20).to_a.join(" ")

* enum = wordwrap(text.split(/\s+/), 10)

* puts "-"*10

* puts "-"*10

* #=> ----------

* # 1 2 3 4 5

* So each mail can be extracted by slice before Unix From line.

*

* # parse mbox

* line.start_with? "From "

* unix_from = mail.shift

* i = mail.index("\n")

* header = mail[0...i]

* body = mail[(i+1)..-1]

* body.pop if body.last == "\n"

* p unix_from

* pp fields

* pp body

* }

*

* # split mails in mbox (slice before Unix From line after an empty line)

* prevemp = h[:emp]

* h[:emp] = line == "\n"

* prevemp && line.start_with?("From ")

* mail.pop if mail.last == "\n"

* pp mail

* }