| instance methods | 
| collect | enumObj.collect {| obj | block }
        -> anArray | 
 | Returns a new array with the results of running block once for every
      element in enumObj. 
  | (1..4).collect {|i| i*i } | » | [1, 4, 9, 16] |  
  | (1..4).collect { "cat"  } | » | ["cat", "cat", "cat", "cat"] |  | | detect | enumObj.detect {| obj | block }
        -> anObject or nil | 
 | Passes each entry in enumObj to block. Returns the first for 
      which block is not false. Returnsnilif no object matches.
  | (1..10).detect  {|i| i % 5 == 0 and i % 7 == 0 } | » | nil |  
  | (1..100).detect {|i| i % 5 == 0 and i % 7 == 0 } | » | 35 |  | | each_with_index | enumObj.each_with_index
        {| obj, i | block }
        -> nil | 
 | Calls block with two arguments, the item and its index,
      for each item in enumObj. 
| hash = Hash.new |  
| %w(cat dog wombat).each_with_index {|item, index| |  
|   hash[item] = index |  
| } |  
  | hash | » | {"dog"=>1, "wombat"=>2, "cat"=>0} |  | | entries | enumObj.entries -> anArray | 
 | Synonym for Enumerable#to_a. | | find | enumObj.find {| obj | block }
        -> anObject or nil | 
 | Synonym for Enumerable#detect. | | find_all | enumObj.find_all {| obj | block }
        -> anArray | 
 | Returns an array containing all elements of enumObj for which
      block is not false(see alsoEnumerable#reject).
  | (1..10).find_all {|i|  i % 3 == 0 } | » | [3, 6, 9] |  | | grep | enumObj.grep( pattern ) -> anArray enumObj.grep( pattern ) {| obj | block }
 -> anArray
 | 
 | Returns an array of every element in enumObj for which Pattern === element. If the optional block is
      supplied, each matching element is passed to it, and the block's
      result is stored in the output array.
  | (1..100).grep 38..44 | » | [38, 39, 40, 41, 42, 43, 44] |  
| c = IO.constants |  
  | c.grep(/SEEK/) | » | ["SEEK_END", "SEEK_CUR", "SEEK_SET"] |  
| res = c.grep(/SEEK/) {|v| IO.const_get(v) } |  
  | res | » | [2, 1, 0] |  | | include? | enumObj.include?( anObject )
      -> trueorfalse | 
 | Returns trueif any member of enumObj equals
      anObject. Equality is tested using==.
  | IO.constants.include? "SEEK_SET" | » | true |  
  | IO.constants.include? "SEEK_NO_FURTHER" | » | false |  | | map | enumObj.map {| obj | block }
        -> anArray | 
 | Synonym for Enumerable#collect. | | max | enumObj.max -> anObject enumObj.max {| a,b | block }
 -> anObject
 | 
 | Returns the object in enumObj with the maximum value. The first
      form assumes all objects implement Comparable; the second
      uses the block to return a <=> b.
| a = %w(albatross dog horse) |  
  | a.max | » | "horse" |  
  | a.max {|a,b| a.length <=> b.length } | » | "albatross" |  | | member? | enumObj.member?( anObject ) -> trueorfalse | 
 | Synonym for Enumerable#include?. | | min | enumObj.min -> anObject enumObj.min {| a,b | block }
 -> anObject
 | 
 | Returns the object in enumObj with the minimum value. The first
      form assumes all objects implement Comparable; the second
      uses the block to return a <=> b.
| a = %w(albatross dog horse) |  
  | a.min | » | "albatross" |  
  | a.min {|a,b| a.length <=> b.length } | » | "dog" |  | | reject | enumObj.reject {| obj | block }
        -> anArray | 
 | Returns an array for all elements of enumObj for which
      block is false(see alsoEnumerable#find_all).
  | (1..10).reject {|i|  i % 3 == 0 } | » | [1, 2, 4, 5, 7, 8, 10] |  | | select | enumObj.select {| obj | block }
        -> anArray | 
 | Synonym for Enumerable#find_all. | | sort | enumObj.sort -> anArray enumObj.sort {| a, b | block }
 -> anArray
 | 
 | Returns an array containing the items in enumObj sorted, either
      according to their own <=>method, or by using the
      results of the supplied block. The block should return -1, 0, or 
      +1 depending on the comparison between a and b.
The following code sorts some files on modification time.
  | %w(rhea kea flea).sort | » | ["flea", "kea", "rhea"] |  
  | (1..10).sort {|a,b| b <=> a} | » | [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] |  
This sort is inefficient: it generates two new
| files = Dir["*"] |  
| sorted = files.sort {|a,b| File.new(a).mtime <=> File.new(b).mtime} |  
  | sorted | » | ["mon", "tues", "wed", "thurs"] |  Fileobjects
      during every comparison. A slightly better technique is to use
      theKernel#testmethod to generate the modification times
      directly.
This still generates many unnecessary
| files = Dir["*"] |  
| sorted = files.sort { |a,b| |  
|   test(?M, a) <=> test(?M, b) |  
| } |  
  | sorted | » | ["mon", "tues", "wed", "thurs"] |  Timeobjects.
      A more efficient technique is to cache
      the sort keys (modification times in this case) before the sort.
      Perl users often call this approach a Schwartzian Transform,                  
      after Randal Schwartz. We construct a temporary array,
      where each element is an array containing our sort key along
      with the filename. We sort this array, and then extract the
      filename from the result.
| sorted = Dir["*"].collect { |f| |  
|    [test(?M, f), f] |  
| }.sort.collect { |f| f[1] } |  
  | sorted | » | ["mon", "tues", "wed", "thurs"] |  | | to_a | enumObj.to_a -> anArray | 
 | Returns an array containing the items in enumObj. 
  | (1..7).to_a | » | [1, 2, 3, 4, 5, 6, 7] |  
  | { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a | » | [["a", 1], ["b", 2], ["c", 3]] |  |