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

----------------------------------------------------------------------