Errata

Change the first paragraph on the page to: The Complex class represents complex numbers, of course. BigDecimal represents real numbers with arbitrary precision, using a decimal representation rather than a binary representation. And Rational represents rational numbers: one integer divided by another. In Ruby 1.8 these classes are in the standard library. In Ruby 1.9, Complex and Rational are built-in. ----------------------------------------------------------------------

Change the first paragraph on the page to: The Complex class represents complex numbers, of course. BigDecimal represents real numbers with arbitrary precision, using a decimal representation rather than a binary representation. And Rational represents rational numbers: one integer divided by another. In Ruby 1.8 these classes are in the standard library. In Ruby 1.9, Complex and Rational are built-in. ----------------------------------------------------------------------

Change this: The modulo (%) operator computes remainder-after-integer division: x = 5%2 # result is 1 The % operator can also be used with Float operands, although this is less common: x = 1.5%0.4 # result is 0.3 To this: The modulo (%) operator (and the synonymous modulo method) compute the remainder after integer division. They can also be used with Float and Rational operands. The divmod returns both quotient and modulo: x = 5%2 # => 1: quotient is 2, with 1 left over q,r = 10.divmod 3 # => [3,1]: quotient is 3, remainder is 1 ----------------------------------------------------------------------

Change this: The division operator depends on the class of the operands. If both operands are integers, then the operation performed is truncating-integer division. If either operand is a Float, then floating-point division is performed: x = 5/2 # result is 2 y = 5.0/2 # result is 2.5 z = 5/2.0 # result is 2.5 To: The division operator depends on the class of the operands: if both operands are integers, then truncating integer division is performed. If either operand is a Float, then floating-point division is performed. There are also three division methods: div performs integer division, fdiv performs floating-point division, and quo returns a Rational when possible, and otherwise returns a Float (this requires the 'rational' module in Ruby 1.8). [5/2, 5.0/2, 5/2.0] # => [2, 2.5, 2.5] [5.0.div(2), 5.0.fdiv(2), 5.quo(2)] # => [2, 2.5, Rational(5,2)] ----------------------------------------------------------------------

Change this: The division operator depends on the class of the operands. If both operands are integers, then the operation performed is truncating-integer division. If either operand is a Float, then floating-point division is performed: x = 5/2 # result is 2 y = 5.0/2 # result is 2.5 z = 5/2.0 # result is 2.5 To: The division operator depends on the class of the operands: if both operands are integers, then truncating integer division is performed. If either operand is a Float, then floating-point division is performed. There are also three division methods: div performs integer division, fdiv performs floating-point division, and quo returns a Rational when possible, and otherwise returns a Float (this requires the 'rational' module in Ruby 1.8). [5/2, 5.0/2, 5/2.0] # => [2, 2.5, 2.5] [5.0.div(2), 5.0.fdiv(2), 5.quo(2)] # => [2, 2.5, Rational(5,2)] ----------------------------------------------------------------------

Change this: The modulo (%) operator computes remainder-after-integer division: x = 5%2 # result is 1 The % operator can also be used with Float operands, although this is less common: x = 1.5%0.4 # result is 0.3 To this: The modulo (%) operator (and the synonymous modulo method) compute the remainder after integer division. They can also be used with Float and Rational operands. The divmod returns both quotient and modulo: x = 5%2 # => 1: quotient is 2, with 1 left over q,r = 10.divmod 3 # => [3,1]: quotient is 3, remainder is 1 ----------------------------------------------------------------------

Change the second paragraph and the block of code that follows it to read: If a string contains multibyte characters, then the number of bytes does not correspond to the number of characters. In Ruby 1.9, the length and size methods return the number of characters in a string, and the new bytesize method returns the number of bytes. The [] and []= operators allow you to query and set the characters of a string, and the new methods getbyte and setbyte allow you to query and set individual bytes (though you should not often need to do this): # -*- coding: utf-8 -*- # Specify Unicode UTF-8 characters # This is a string literal containing a multibyte multiplication character s = "2√ó2=4" # The string contains 6 bytes which encode 5 characters s.bytesize # => 6 s.bytesize.times {|i| print s.getbyte(i), " "} # Prints "50 195 151 50 61 52" s.length # => 5 s.length.times { |i| print s[i], " "} # Prints "2 √ó 2 = 4" s.setbyte(5, s.getbyte(5)+1); # s is now "2√ó2=5" ----------------------------------------------------------------------

Change the second paragraph and the block of code that follows it to read: If a string contains multibyte characters, then the number of bytes does not correspond to the number of characters. In Ruby 1.9, the length and size methods return the number of characters in a string, and the new bytesize method returns the number of bytes. The [] and []= operators allow you to query and set the characters of a string, and the new methods getbyte and setbyte allow you to query and set individual bytes (though you should not often need to do this): # -*- coding: utf-8 -*- # Specify Unicode UTF-8 characters # This is a string literal containing a multibyte multiplication character s = "2√ó2=4" # The string contains 6 bytes which encode 5 characters s.bytesize # => 6 s.bytesize.times {|i| print s.getbyte(i), " "} # Prints "50 195 151 50 61 52" s.length # => 5 s.length.times { |i| print s[i], " "} # Prints "2 √ó 2 = 4" s.setbyte(5, s.getbyte(5)+1); # s is now "2√ó2=5" ----------------------------------------------------------------------

Change "When you use the [] operator to access" to "When you use the [] operator, as we did in the code above, to access". ----------------------------------------------------------------------

Change this line: t.encoding # => <Encoding: ASCII-8BIT> To: t.encoding # => <Encoding: US-ASCII> ----------------------------------------------------------------------

Delete this text: Because the "BINARY" encoding really means "unencoded bytes," you can also specify this encoding by passing nil instead of an encoding name or Encoding object. Add this sentence at the end of the 3rd paragraph: The encoding name "ASCII" is an alias for "US-ASCII". ----------------------------------------------------------------------

Change "When you use the [] operator to access" to "When you use the [] operator, as we did in the code above, to access". ----------------------------------------------------------------------

Change this line: t.encoding # => <Encoding: ASCII-8BIT> To: t.encoding # => <Encoding: US-ASCII> ----------------------------------------------------------------------

Delete this text: Because the "BINARY" encoding really means "unencoded bytes," you can also specify this encoding by passing nil instead of an encoding name or Encoding object. Add this sentence at the end of the 3rd paragraph: The encoding name "ASCII" is an alias for "US-ASCII". ----------------------------------------------------------------------

Change "raises an exception;" to "raises an exception:" Change the two lines of code that follow to: "u20AC".encode("iso-8859-1") # No euro sign in Latin-1, so raise exception Then add this new paragraph: encode and encode! accept a hash of transcoding options as their final argument. At the time of this writing, the only defined option name is :invalid, and the only defined value for that key is :ignore. "ri String.encode" will give details when more options are implemented. ----------------------------------------------------------------------

Change "raises an exception;" to "raises an exception:" Change the two lines of code that follow to: "u20AC".encode("iso-8859-1") # No euro sign in Latin-1, so raise exception Then add this new paragraph: encode and encode! accept a hash of transcoding options as their final argument. At the time of this writing, the only defined option name is :invalid, and the only defined value for that key is :ignore. "ri String.encode" will give details when more options are implemented. ----------------------------------------------------------------------

In the first paragraph, delete: but these are dynamically loaded as needed rather than built-in, and constants do not exist for these encodings until they are used. Change the 4th paragraph on the page from: If you want a list of available encodings, call Encoding.list, which returns an array of Encoding objects. The Encoding.list method only lists built-in encodings and any encodings that have already been dynamically loaded. Calling Encoding.find can cause new encodings to be loaded. These new encodings will be listed by subsequent calls to Encoding.list. To: Encoding.list returns an array of all available encoding objects. Encoding.name_list returns an array of the names (as strings) of all available encodings. Many encodings have more than one name in common use, and Encoding.aliases returns a hash that maps encoding aliases to the official encoding names for which they are synonyms. The array returned by Encoding.name_list includes the aliases in the Encoding.aliases hash. In the 6th paragraph, cut: will also accept nil as a synonym for Encoding::BINARY (i.e., unencoded bytes). Most methods In the same paragraph change "an encoding name" to "a case-insensitive encoding name" Finally, delete the entire last paragraph of Section 3.2.6.2. ----------------------------------------------------------------------

In the first paragraph, delete: but these are dynamically loaded as needed rather than built-in, and constants do not exist for these encodings until they are used. Change the 4th paragraph on the page from: If you want a list of available encodings, call Encoding.list, which returns an array of Encoding objects. The Encoding.list method only lists built-in encodings and any encodings that have already been dynamically loaded. Calling Encoding.find can cause new encodings to be loaded. These new encodings will be listed by subsequent calls to Encoding.list. To: Encoding.list returns an array of all available encoding objects. Encoding.name_list returns an array of the names (as strings) of all available encodings. Many encodings have more than one name in common use, and Encoding.aliases returns a hash that maps encoding aliases to the official encoding names for which they are synonyms. The array returned by Encoding.name_list includes the aliases in the Encoding.aliases hash. In the 6th paragraph, cut: will also accept nil as a synonym for Encoding::BINARY (i.e., unencoded bytes). Most methods In the same paragraph change "an encoding name" to "a case-insensitive encoding name" Finally, delete the entire last paragraph of Section 3.2.6.2. ----------------------------------------------------------------------

Change this sentence (in the middle of the page): Use << to append elements to the end of an existing array: So that it reads: Use << to append an element to the end of an existing array, and use concat to append the elements of an array: Then, at the end of the code block that follows, add this line: a.concat [7,8] # a is [1, 2, 3, [4, 5, 6], 7, 8] Line up the # mark with the ones above it, of course. Also, move the paragraph that begins "The - operator subtracts" and the one line of code that follows it, so that it comes after this discussion of << and concat (and before the paragraph that begins "Like the String class..." ----------------------------------------------------------------------

Change this sentence (in the middle of the page): Use << to append elements to the end of an existing array: So that it reads: Use << to append an element to the end of an existing array, and use concat to append the elements of an array: Then, at the end of the code block that follows, add this line: a.concat [7,8] # a is [1, 2, 3, [4, 5, 6], 7, 8] Line up the # mark with the ones above it, of course. Also, move the paragraph that begins "The - operator subtracts" and the one line of code that follows it, so that it comes after this discussion of << and concat (and before the paragraph that begins "Like the String class..." ----------------------------------------------------------------------

Add this sentence to the end of the paragraph: Ruby 1.9 adds to_c and to_r methods to convert to Complex and Rational. ----------------------------------------------------------------------

Add this sentence to the end of the paragraph: Ruby 1.9 adds to_c and to_r methods to convert to Complex and Rational. ----------------------------------------------------------------------

Change "(in Ruby 1.9)" to "(in Ruby 1.9 and 1.8.7)" ----------------------------------------------------------------------

Change "(in Ruby 1.9)" to "(in Ruby 1.9 and 1.8.7)" ----------------------------------------------------------------------

Change the 3rd and 4th sentences of this paragraph to read: In Ruby 1.9 (and also 1.8.7), enumerators are built-in and no require is necessary. (As we'll see later, the built-in enumerators have substantially more functionality than that provided by the enumerator library.) ----------------------------------------------------------------------

Change the 3rd and 4th sentences of this paragraph to read: In Ruby 1.9 (and also 1.8.7), enumerators are built-in and no require is necessary. (As we'll see later, the built-in enumerators have substantially more functionality than that provided by the enumerator library.) ----------------------------------------------------------------------

Change "In Ruby 1.9" to "In Ruby 1.9 (and 1.8.7)" ----------------------------------------------------------------------

Remove the footnote on this page ----------------------------------------------------------------------

Change "In Ruby 1.9" to "In Ruby 1.9 (and 1.8.7)" ----------------------------------------------------------------------

Remove the footnote on this page ----------------------------------------------------------------------

In the 2nd sentence of this section, change "In Ruby 1.9" to "In Ruby 1.9 (and 1.8.7, though the implementation is not as efficient)" ----------------------------------------------------------------------

In the 2nd sentence of this section, change "In Ruby 1.9" to "In Ruby 1.9 (and 1.8.7, though the implementation is not as efficient)" ----------------------------------------------------------------------

Change "Expression class" to "Exception class" ----------------------------------------------------------------------

Change "Expression class" to "Exception class" ----------------------------------------------------------------------

Add this new paragraph and code at the end of section 6.5.2 Ruby 1.9 adds a curry method to the Proc class. Calling this method returns a curried version of a proc or lambda. When a curried proc or lambda is invoked with insufficient arguments it returns a new Proc object (also curried) with the given arguments applied. Currying is a common technique in the functional programming paradigm: product = ->(x,y){ x*y } # Define a lambda triple = product.curry[3] # Curry it, then specify the first argument [triple[10],triple[20]] # => [30,60]: lambda {|w,x,y,z| w+x+y+z}.curry[1][2,3][4] # => 10 ----------------------------------------------------------------------

Add this new paragraph and code at the end of section 6.5.2 Ruby 1.9 adds a curry method to the Proc class. Calling this method returns a curried version of a proc or lambda. When a curried proc or lambda is invoked with insufficient arguments it returns a new Proc object (also curried) with the given arguments applied. Currying is a common technique in the functional programming paradigm: product = ->(x,y){ x*y } # Define a lambda triple = product.curry[3] # Curry it, then specify the first argument [triple[10],triple[20]] # => [30,60]: lambda {|w,x,y,z| w+x+y+z}.curry[1][2,3][4] # => 10 ----------------------------------------------------------------------

Insert the following right before "For example:" This is similar to, but not quite the same as currying with the Proc.curry method. ----------------------------------------------------------------------

Insert the following right before "For example:" This is similar to, but not quite the same as currying with the Proc.curry method. ----------------------------------------------------------------------

Add a new sentence at the end of this box: Methods such as ==, equal?, instance_eval, and __send__, are normally considered to be Object methods even though they are actually defined by BasicObject. ----------------------------------------------------------------------

Add a new sentence at the end of this box: Methods such as ==, equal?, instance_eval, and __send__, are normally considered to be Object methods even though they are actually defined by BasicObject. ----------------------------------------------------------------------

Insert a new paragraph right before "Despite these overall": Ruby 1.9 also defines a require_relative method. It works like require, except that it ignores the load path and searches relative to the directory from which the invoking code was loaded. ----------------------------------------------------------------------

Insert a new paragraph right before "Despite these overall": Ruby 1.9 also defines a require_relative method. It works like require, except that it ignores the load path and searches relative to the directory from which the invoking code was loaded. ----------------------------------------------------------------------

Change these lines of code: # Add the installation directory for the current program to # the beginning of the load path To: # Add the installation directory for the current program to # the beginning of the load path instead of using require_relative ----------------------------------------------------------------------

Change these lines of code: # Add the installation directory for the current program to # the beginning of the load path To: # Add the installation directory for the current program to # the beginning of the load path instead of using require_relative ----------------------------------------------------------------------

Add these two lines of code at the bottom of the page # In Ruby 1.9, you can specify a hash to map matches to replacements s.gsub(/[aeiou]/,"a"=>0, "e"=>1, "i"=>2) # => "h1ll" ----------------------------------------------------------------------

Add these two lines of code at the bottom of the page # In Ruby 1.9, you can specify a hash to map matches to replacements s.gsub(/[aeiou]/,"a"=>0, "e"=>1, "i"=>2) # => "h1ll" ----------------------------------------------------------------------

Change "Ruby 1.9" to "Ruby 1.9 (and 1.8.7)" ----------------------------------------------------------------------

Change "Ruby 1.9" to "Ruby 1.9 (and 1.8.7)" ----------------------------------------------------------------------

In the block of code in the middle of the page, change: phone.gsub!(/D/, "") # Remove anything other than digits To: phone.gsub!(/D/,' '=>'-') # 1.9: remove non-digits but map space to hyphen Insert the following after the first sentence of the last paragraph on the page: (Replacement strings specified in a hash must be ordinary strings, however.) ----------------------------------------------------------------------

In the block of code in the middle of the page, change: phone.gsub!(/D/, "") # Remove anything other than digits To: phone.gsub!(/D/,' '=>'-') # 1.9: remove non-digits but map space to hyphen Insert the following after the first sentence of the last paragraph on the page: (Replacement strings specified in a hash must be ordinary strings, however.) ----------------------------------------------------------------------

Change the sentence at the top of the page to: Numeric and its subclasses define various methods for rounding numbers: After the code block, change "Float also defines a few other" to "Here are a few other numeric" Then replace the final block of code in 9.3.1 with this: # For any Numeric value n, in Ruby 1.9 [n.abs, n<=>0] # Absolute value and sign [n.abs, n.angle] # Magnitude and angle (or use n.polar) [n.numerator, n.denominator] # Numerator and denominator [n.real, n.imag] # Real and imaginary parts # Floating point constants: may be implementation dependent [Float::MAX, Float::MIN] # => [1.79769313486232e+308,2.2250738585072e-308] Float::EPSILON # => 2.22044604925031e-16: difference between adjacent floats ----------------------------------------------------------------------

Insert this line: Math.cbrt(27.0) # => 3.0: cube root; Ruby 1.9 and later After this line: Math.sqrt(25.0) # => 5.0: square root ----------------------------------------------------------------------

Change the sentence at the top of the page to: Numeric and its subclasses define various methods for rounding numbers: After the code block, change "Float also defines a few other" to "Here are a few other numeric" Then replace the final block of code in 9.3.1 with this: # For any Numeric value n, in Ruby 1.9 [n.abs, n<=>0] # Absolute value and sign [n.abs, n.angle] # Magnitude and angle (or use n.polar) [n.numerator, n.denominator] # Numerator and denominator [n.real, n.imag] # Real and imaginary parts # Floating point constants: may be implementation dependent [Float::MAX, Float::MIN] # => [1.79769313486232e+308,2.2250738585072e-308] Float::EPSILON # => 2.22044604925031e-16: difference between adjacent floats ----------------------------------------------------------------------

Insert this line: Math.cbrt(27.0) # => 3.0: cube root; Ruby 1.9 and later After this line: Math.sqrt(25.0) # => 5.0: square root ----------------------------------------------------------------------

Change the following lines: # Decompose float x into fraction f and exponent e, such that x = f*2**e f,e = frexp(1024.0) # => [0.5, 11] x = ldexp(f, e) # => 1024: compute x = f*2**e # Error function erf(0.0) # => 0.0: error function erfc(0.0) # => 1.0: 1-erf(x): complementary error function To read: # Miscellaneous Functions f,e = frexp(1024.0) # => [0.5, 11]: decompose x into [f,e], x = f*2**e x = ldexp(f, e) # => 1024: compute x = f*2**e erf(0.0) # => 0.0: error function erfc(0.0) # => 1.0: 1-erf(x): complementary error function gamma(5) # => 24.0: floating-point factorial function lgamma(100) # => [359.134205369575, 1]: logarithmic gamma ----------------------------------------------------------------------

Change the first paragraph of 9.3.4 to read: The Complex class represents complex numbers. It is a core class in 1.9 and part of the standard library in 1.8. Requiring the 'complex' module (in either 1.8 or 1.9) redefines the methods of the Math module so that they can accept and return complex numbers. In Ruby 1.9 you can instead require 'cmath' to define a CMath module that defines complex-enabled versions of the Math methods. Examples: ----------------------------------------------------------------------

Change the first paragraph of 9.3.4 to read: The Complex class represents complex numbers. It is a core class in 1.9 and part of the standard library in 1.8. Requiring the 'complex' module (in either 1.8 or 1.9) redefines the methods of the Math module so that they can accept and return complex numbers. In Ruby 1.9 you can instead require 'cmath' to define a CMath module that defines complex-enabled versions of the Math methods. Examples: ----------------------------------------------------------------------

Change the following lines: # Decompose float x into fraction f and exponent e, such that x = f*2**e f,e = frexp(1024.0) # => [0.5, 11] x = ldexp(f, e) # => 1024: compute x = f*2**e # Error function erf(0.0) # => 0.0: error function erfc(0.0) # => 1.0: 1-erf(x): complementary error function To read: # Miscellaneous Functions f,e = frexp(1024.0) # => [0.5, 11]: decompose x into [f,e], x = f*2**e x = ldexp(f, e) # => 1024: compute x = f*2**e erf(0.0) # => 0.0: error function erfc(0.0) # => 1.0: 1-erf(x): complementary error function gamma(5) # => 24.0: floating-point factorial function lgamma(100) # => [359.134205369575, 1]: logarithmic gamma ----------------------------------------------------------------------

Change the lines of code at the top of the page to the following: require "complex" # Ruby 1.8 and for complex Math methods in 1.9 c = Complex(0.5,-0.2) # => .5-.2i. Complex.polar(1,Math::PI/2) # => Complex(0.0,1.0): create with polar coords i = 1.im # => Complex(0,1): convert to imaginary number (2.re - 3.5.im).to_s # => "2.5-3.5i": re method in Ruby 1.9 only r,i = c.real, c.imag # => [0.5,-0.2]: Real part, imaginary part m,a = c.polar # => [magnitude, angle]: Same as [c.abs,c.angle] d = c.conj # => .5+.2i: change sign of imaginary part z = "0+0i".to_c # String-to-Complex conversion function: 1.9 only 10.times { z = z*z + c } # Arithmetic operators work on Complex numbers 1.im**2 # => Complex(-1,0): i*i == -1 x = Math.sin(z) # 'complex' module redefines Math functions require 'cmath' # Ruby 1.9: Define CMath module for complex math CMath.sqrt(-1)==Complex::I # => true ----------------------------------------------------------------------

Change this section to the following: The Rational class represents rational numbers (the quotient of two integers). Rational is built-in to Ruby 1.9 and is part of the standard library in Ruby 1.8. Division with the quo method returns a Rational value if both arguments are integers. Some examples: require "rational" # Only necessary in Ruby 1.8 penny = Rational(1, 100) # A penny is 1/100th nickel = "5/100".to_r # String-to-Rational conversion: Ruby 1.9 only dime = 10.quo 100 # => Rational(1,10) change = 2*dime + 3*penny # => Rational(23,100) change.numerator # => 23: top of the fraction change.denominator # => 100: bottom of the fraction change.to_f # => 0.23: convert to Float (nickel * dime).to_s # => "1/200": to_s returns fractions ----------------------------------------------------------------------

Change the lines of code at the top of the page to the following: require "complex" # Ruby 1.8 and for complex Math methods in 1.9 c = Complex(0.5,-0.2) # => .5-.2i. Complex.polar(1,Math::PI/2) # => Complex(0.0,1.0): create with polar coords i = 1.im # => Complex(0,1): convert to imaginary number (2.re - 3.5.im).to_s # => "2.5-3.5i": re method in Ruby 1.9 only r,i = c.real, c.imag # => [0.5,-0.2]: Real part, imaginary part m,a = c.polar # => [magnitude, angle]: Same as [c.abs,c.angle] d = c.conj # => .5+.2i: change sign of imaginary part z = "0+0i".to_c # String-to-Complex conversion function: 1.9 only 10.times { z = z*z + c } # Arithmetic operators work on Complex numbers 1.im**2 # => Complex(-1,0): i*i == -1 x = Math.sin(z) # 'complex' module redefines Math functions require 'cmath' # Ruby 1.9: Define CMath module for complex math CMath.sqrt(-1)==Complex::I # => true ----------------------------------------------------------------------

Change this section to the following: The Rational class represents rational numbers (the quotient of two integers). Rational is built-in to Ruby 1.9 and is part of the standard library in Ruby 1.8. Division with the quo method returns a Rational value if both arguments are integers. Some examples: require "rational" # Only necessary in Ruby 1.8 penny = Rational(1, 100) # A penny is 1/100th nickel = "5/100".to_r # String-to-Rational conversion: Ruby 1.9 only dime = 10.quo 100 # => Rational(1,10) change = 2*dime + 3*penny # => Rational(23,100) change.numerator # => 23: top of the fraction change.denominator # => 100: bottom of the fraction change.to_f # => 0.23: convert to Float (nickel * dime).to_s # => "1/200": to_s returns fractions ----------------------------------------------------------------------

Insert this paragraph: For cryptographically secure random numbers, use the SecureRandom module, which is part of the standard library in Ruby 1.9 and 1.8.7. ----------------------------------------------------------------------

Insert this paragraph: For cryptographically secure random numbers, use the SecureRandom module, which is part of the standard library in Ruby 1.9 and 1.8.7. ----------------------------------------------------------------------

Change "in Ruby 1.9" to "in Ruby 1.9 (and 1.8.7)". ----------------------------------------------------------------------

In the paragraph about the zip method, delete this text: in Ruby 1.8 or an enumerator object in Ruby 1.9 (calling to_a on the enumerator object generates the array of arrays that would have been returned in 1.8) Then add the following two lines of code to the code that follows that paragraph: p (1..3).zip('a'..'z') # Prints [[1,"a"],[2,"b"],[3,"c"]] p (1..3).zip('a'..'b') # Prints [[1,"a"],[2,"b"],[3,nil]] ----------------------------------------------------------------------

Change "in Ruby 1.9" to "in Ruby 1.9 (and 1.8.7)". ----------------------------------------------------------------------

In the paragraph about the zip method, delete this text: in Ruby 1.8 or an enumerator object in Ruby 1.9 (calling to_a on the enumerator object generates the array of arrays that would have been returned in 1.8) Then add the following two lines of code to the code that follows that paragraph: p (1..3).zip('a'..'z') # Prints [[1,"a"],[2,"b"],[3,"c"]] p (1..3).zip('a'..'b') # Prints [[1,"a"],[2,"b"],[3,nil]] ----------------------------------------------------------------------

Change "Ruby 1.9" to "Ruby 1.9 (and 1.8.7)" ----------------------------------------------------------------------

Change "Ruby 1.9" to "Ruby 1.9 (and 1.8.7)" ----------------------------------------------------------------------

Change the paragraph that begin "In Ruby 1.9" to read: The find_index method (new in Ruby 1.9) is like the index method of Array: it returns the index of a specific element or of the first element that matches a block: Then add this line of code before the two following lines: data.find_index [0,1] # => 1: the second element matches ----------------------------------------------------------------------

Change the paragraph that begin "In Ruby 1.9" to read: The find_index method (new in Ruby 1.9) is like the index method of Array: it returns the index of a specific element or of the first element that matches a block: Then add this line of code before the two following lines: data.find_index [0,1] # => 1: the second element matches ----------------------------------------------------------------------

Insert a new paragraph right before 9.5.1.6: The Array class defines its own efficient versions of these taking and dropping methods that do not require arrays to be iterated with each. ----------------------------------------------------------------------

Insert a new paragraph right before 9.5.1.6: The Array class defines its own efficient versions of these taking and dropping methods that do not require arrays to be iterated with each. ----------------------------------------------------------------------

Change: [1,2,3].nitems {|x| x>2} # => 1: # of elts matching block (Ruby 1.9) To: [1,2,3].nitems {|x| x>2} # => 1: # of elts matching block (Ruby 1.9 + 1.8.7) ----------------------------------------------------------------------

Change: [1,2,3].nitems {|x| x>2} # => 1: # of elts matching block (Ruby 1.9) To: [1,2,3].nitems {|x| x>2} # => 1: # of elts matching block (Ruby 1.9 + 1.8.7) ----------------------------------------------------------------------

Add this sentence at the end of the first paragraph In Ruby 1.9 and 1.8.7, array iterators return an enumerator when invoked without a block: ----------------------------------------------------------------------

Add this sentence at the end of the first paragraph In Ruby 1.9 and 1.8.7, array iterators return an enumerator when invoked without a block: ----------------------------------------------------------------------

Change these lines: a.index {|c| c =~ /[aeiou]/} # => 1: index of first vowel. Ruby 1.9. a.rindex {|c| c =~ /[aeiou]/} # => 4: index of last vowel. Ruby 1.9. To: a.index {|c| c =~ /[aeiou]/} # => 1: index of 1st vowel. 1.9 and 1.8.7 a.rindex {|c| c =~ /[aeiou]/} # => 4: index of last vowel. 1.9 and 1.8.7 ----------------------------------------------------------------------

Change these lines: a.index {|c| c =~ /[aeiou]/} # => 1: index of first vowel. Ruby 1.9. a.rindex {|c| c =~ /[aeiou]/} # => 4: index of last vowel. Ruby 1.9. To: a.index {|c| c =~ /[aeiou]/} # => 1: index of 1st vowel. 1.9 and 1.8.7 a.rindex {|c| c =~ /[aeiou]/} # => 4: index of last vowel. 1.9 and 1.8.7 ----------------------------------------------------------------------

Delete the second paragraph from the bottom. Matz says that the compare_by_identity method will likely be removed ----------------------------------------------------------------------

Delete the second paragraph from the bottom. Matz says that the compare_by_identity method will likely be removed ----------------------------------------------------------------------

Insert the following before "To change the name of a file": To copy a file, use File.copy_stream, specifying filenames as the source and destination: File.copy_stream("test", "test.backup") ----------------------------------------------------------------------

Insert the following before "To change the name of a file": To copy a file, use File.copy_stream, specifying filenames as the source and destination: File.copy_stream("test", "test.backup") ----------------------------------------------------------------------

At the end of the first paragraph, replace this sentence: None of these class methods requires you to instantiate an IO object: With this: In Ruby 1.9, you can pass a hash to these methods to specify the mode string and/or encoding of the file being read. After the first line of code in the section insert these two lines: data = IO.read("data", mode:"rb") # Open with mode string "rb" data = IO.read("data", encoding:"binary") # Read unencoded bytes Insert the following before the paragraph that begins "Although" In Ruby 1.9 you can use IO.copy_stream to read a file (or a portion) and write its content to a stream: IO.copy_stream("/usr/share/dict/words", STDOUT) # Print the dictionary IO.copy_stream("/usr/share/dict/words", STDOUT, 10, 100) # Print bytes 100-109 At the end of the next paragraph, change "and File.foreach" to "File.foreach, and File.copy_stream" ----------------------------------------------------------------------

At the end of the first paragraph, replace this sentence: None of these class methods requires you to instantiate an IO object: With this: In Ruby 1.9, you can pass a hash to these methods to specify the mode string and/or encoding of the file being read. After the first line of code in the section insert these two lines: data = IO.read("data", mode:"rb") # Open with mode string "rb" data = IO.read("data", encoding:"binary") # Read unencoded bytes Insert the following before the paragraph that begins "Although" In Ruby 1.9 you can use IO.copy_stream to read a file (or a portion) and write its content to a stream: IO.copy_stream("/usr/share/dict/words", STDOUT) # Print the dictionary IO.copy_stream("/usr/share/dict/words", STDOUT, 10, 100) # Print bytes 100-109 At the end of the next paragraph, change "and File.foreach" to "File.foreach, and File.copy_stream" ----------------------------------------------------------------------

Replace these lines: Another way to read the bytes of a stream is with the each_byte iterator. This method passes each byte of a stream to the associated block: f.each_byte {|b| ... } # Iterate through remaining bytes f.bytes # An enumerator for each_byte: Ruby 1.9 With these: You can also iterate and enumerate the characters and bytes of a stream: f.each_byte {|b| ... } # Iterate through remaining bytes f.bytes # An enumerator for each_byte: Ruby 1.9 f.each_char {|c} ...} # Iterate characters: Ruby 1.9 f.chars # An enumerator for each_char: Ruby 1.9 ----------------------------------------------------------------------

Replace these lines: Another way to read the bytes of a stream is with the each_byte iterator. This method passes each byte of a stream to the associated block: f.each_byte {|b| ... } # Iterate through remaining bytes f.bytes # An enumerator for each_byte: Ruby 1.9 With these: You can also iterate and enumerate the characters and bytes of a stream: f.each_byte {|b| ... } # Iterate through remaining bytes f.bytes # An enumerator for each_byte: Ruby 1.9 f.each_char {|c} ...} # Iterate characters: Ruby 1.9 f.chars # An enumerator for each_char: Ruby 1.9 ----------------------------------------------------------------------

Change "-r, and -K options" to "-r, -K, -E, and -T" options. Change "on the command line" to "on the command line, unless the command line includes --disable-rubyopt ----------------------------------------------------------------------

Change "-r, and -K options" to "-r, -K, -E, and -T" options. Change "on the command line" to "on the command line, unless the command line includes --disable-rubyopt ----------------------------------------------------------------------