Errata

The book seems never to mention the RUBYLIB environment variable (except once in the 10.5 Security chapter, but it doesn't explain what it is, there or elsewhere). This is a crucial piece of information and should not be omitted. Modification of RUBYLIB is a very important technique.

= album.getTracks.mapToInt( ...

Will not compile. .stream() is missing.

Must be: = album.getTracks.stream().mapToInt( ...

The pervasive phrase "from other languages" is misleading at best; what is familiar depends on what languages you know. In particular, || is concatenation in some languages, not short circuit or. Phrases like "C-like languages" are more accurate. Some examples from other languages include

|| Concatenation of strings
||| Concatenation of lists
| Logical or
& Logical and
& Concatenation of strings
^ Logical and
^ Exponentiation
ª Exclusive or
ª Unary logical not
++ Union of csets
** Intersection of csets
:= Assignment
= Equal
== Strictly equal
<< Strictly less than
>> Strictly greater than

The code is
a[3] = a[2] - 1
but should be
a[3] = a[2] + 1
to produce the output "4321"

In section 5.1.2, the third column of the three examples showing how to express an if structure:

(
line1
line2
) end if expression

...the word "end" is a mistake and should be deleted.

generation = case birthyear
when 1946..1963: "Baby Boomer"
when 1964..1976: "Generation X"
when 1978..2000: "Generation Y"
else nil
end

Comment:
According to the footnote on page 123, a colon (:) should not be used to terminate a when clause.

The when clauses don't cover year 1977.

(Found in the 12/08 edition; haven't examined other editions.)
The line "@grid = @grid.dup" in the dup method defined in the Sudoku solver's Puzzle class doesn't assign to the new Puzzle object a new duplicate of the @grid array. Instead, the original Puzzle object is assigned a new duplicate @grid, and the original @grid has been moved to the new Puzzle object. Although this may not cause a problem in the context of the Suduko solver, the technique seems misleading and potentially risky.

Here's test code that demonstrates the problem:

class Puz
def initialize(grid)
@grid = grid
end
def dup
copy = super
@grid = @grid.dup
copy
end
def grid_objid
@grid.object_id
end
end
#----------------------
pz = Puz.new("xyzzy")
puts "pz grid object id is: #{pz.grid_objid}"
pz2 = pz.dup
puts "pz grid object id is now: #{pz.grid_objid}"
puts "pz2 grid object id is: #{pz2.grid_objid}"

The line:
x = "#This is a string" # And this is a comment

...should correctly read:
x = "#This is a string" # And this is not a comment

The line:
y = /#This is a regular expression/ # Here's another comment

...should correctly read:
y = /#This is a regular expression/ # And this is also not a comment

It is mentioned that:
Any text that appears after =begin "or" =end is part of the comment...

I think that the ONLY text that is ignored is the one after =begin, right?

Thanks.

The text accompanying the example seems say that it is useful to consider control structure expressions such as if then...end as statements, even though they are expressions.

But the comments next to the code implies that the constituent expressions print x and x = x + 1 should be considered separate statements.

Shouldn't it be the whole control structure that is considered a statement? Or is it that these control expressions *contain* statements?

Thanks for any clarification,
Brian

The following sentence...

After these lines have been read, the three string literals are concatenated into one.

...should also indicate that the the string concatenation is joined by newlines...

After these lines have been read, the three string literals are concatenated into one, joined by newlines (
).

The code example...

listing = Kernel.`(listcmd)

...is missing a closing `, but in either case (with or without a closing `) results in errors:

>> listcmd = 'ls'
=> "ls"
>> listing = Kernel.`(listcmd)
`# had to enter closing ` to proceed
SyntaxError: compile error
(irb):46: unterminated string meets end of file
from (irb):46
from :0
>> listing = Kernel.`(listcmd)`
SyntaxError: compile error
(irb):47: syntax error, unexpected tXSTRING_BEG, expecting $end
from (irb):47
from :0

a = 0;

It's better to remove the unnecessary semicolon (;).

s = 'hello'; # Ruby 1.8

s = 'hello'; # Ruby 1.9

It's better to remove unnecessary semicolons (;).

s[s.length] = ?! succeeds in Ruby 1.9. The book states it is an error.

irb(main):001:0> s = 'hello'
=> "hello"
irb(main):002:0> s[s.length] = ?!
=> "!"
irb(main):003:0> s
=> "hello!"
irb(main):004:0>

$ ruby --version
ruby 1.9.1 (2008-12-16 revision 20770) [i686-linux]

s["l"] = "L"; # Replace first occurrence of "l" with "L"

It's better to remove the unnecessary semicolon (;).

s.each_char {|x| print "#{x} " } # Prints "? 1 0 0 0". Ruby 1.9

The comment should be

# Prints "? 1 0 0 0 ". Ruby 1.9

(Add a space after the third 0.)

s = "hello"
while(s["l"])
s["l"] = "L";
end

Comment:
Change the code as shown below to honor Ruby's conventions:

s = "hello"
while s["l"]
s["l"] = "L"
end

2nd line - remove parentheses *
3rd line - remove ;

* Apply this change to the while statements on the following pages as well:
134, 135, 148, 149, 151, 189, 190 (2 instances), 191, 386

s.bytesize.times {|i| print s.getbyte(i), " "} # Prints "50 195 151 50 61 52"

Change the comment to

# Prints "50 195 151 50 61 52 "

(Add a space after 52)

---

s.length.times { |i| print s[i], " "} # Prints "2 ? 2 = 4"

Change the comment to

# Prints "2 ? 2 = 4 "

(Add a space after 4)

---

s.setbyte(5, s.getbyte(5)+1); # s is now "2?2=5"

It's better to remove the unnecessary semicolon (;).

Comment saying

# Transcode to Latin-15

should be

# Transcode to Latin-9

because that is the latin-X equivalent of ISO-8859-15.

See http://en.wikipedia.org/wiki/ISO/IEC_8859-15

Ruby includes a special-case syntax for expressing array literals whose elements are short strings without spaces:

Comment:
Remove "short". The syntax doesn't limit strings to be short.

Paragraph states "Note that these operators are not transitive: a|b is not the same as b|a, for example."

You're confusing "transitive" with "commutative." "Transitive" refers to relations like "<", and states, e.g. that (a < b && b < c) => (a < c).

It is mentioned that | is not "transitive", while in fact the author(s) explain that it is not *commutative*.

"transitive" should be "commutative". An operation O is commutative if for every a and b, a O b = b O a; a *relation* R is transitive if whenever a R b and b R c then a R c.

only if it is a value returned by one of the succ invocations.

Comment:

Change to

only if it is a start value or a value returned by one of the succ invocations.

On page 29 the author said "Class and module names must begin with initial capital letters." So I assume that "myObject = myClass.new" is a mistake. Also, there's a discrepancy in the name of the class between that code snippet and the following sentence, where the name of the class is given as "Class."

At the start of the 8th paragraph, the following sentence appears:

"Ruby objects never need to be explicitly deallocated, as they do in languages like C and C++"

While it is correct that in C++ objects need to be explicitly deallocated, this is not the case in C because C is not an object-oriented language. The sentence should say something like the following instead:

"Ruby objects never need to be explicitly deallocated as they do in C++"

we would also like to know if the object is an instance of any subclass of that class.

Comment:
Change subclass -> superclass

The Class class defines the === operator

Comment:
The Class class doesn't define the === operator but inherits it.

The equal? method is defined by Object

Comment:
For accuracy, make a reference to "BasicObject in Ruby 1.9" on page 235.

And Class defines === to test whether an object is an instance of that class.

Comment:
According to the Ruby 1.9 documentation, Class doesn't define === but it inherits ===.

Suppose you want to test whether the variable x is nil or not. In some languages, you must explicitly write a comparison expression that evaluates to true or false:

if x != nil # Expression "x != nil" returns true or false to the if
puts x # Print x if it is defined
end

This code works in Ruby, but it is more common simply to take advantage of the fact that all values other than nil and false behave like true:

if x # If x is non-nil
puts x # Then print it
end

Comment:
It sounds you're saying you can rewrite the first code snippet to the second but these code snippets behave differently when x == false.

s[0] = "ni" # TypeError: can't modify frozen string

Comment:
Ruby 1.9 returns RuntimeError, not TypeError.

"If a . or :: appears in an expression" should be "If a period not part of a numeric constant or a :: not part of a quoted string appears in an expression"

the following sentence is incorrect:
"Then o.m can be used as an lvalue in an assignment expression."

An lvalue is an address of something, so that the compiler or
interpreter can store the value from the right side there. But in the
example "o.m" does not have an address, as it is a method invocation.
The complete term "o.m = v" is no assignment at all. This is even noted
in the first sentence of this section: "Assignment to an attribute or
array element is actually Ruby shorthand for method invocation."

I know the || operator from other languages, and it's concatenation. Only in languages derived from C is || short circuit or. The text should not make assumptions about what languages the reader knows.

Finally, recall that earlier we described two simple cases of parallel assignment in which there is a single lvalue or a single rvalue.

Comment:
Change "a single rvalue" to "a single array rvalue" because this explanation applies to a case like
x, y, z = [1, 2, 3]
but not to a case like
x, y, z = 1

In order for it to work, b must be a splattable object such as an array or enumerator.

Comment:
It is inaccurate to say that b must be a splattable object in order for
x,(y,z) = a, b
to work. If a=1 and b=2, the result is x=1, y=2, z=nil and the assignment still "works." Tested with Ruby 1.9.2 on Windows.

The return value of a parallel assignment expression is the array of rvalues (after being augmented by any splat operators).

Comment:
Ruby 1.9.2 on Windows doesn't give the stated result:
>> x, y = 1, 2
=> [1, 2]
>> x, y = 1
=> 1
The return value of the first assignment is an array but that of the second assignment is not an array [1].

x || y && nil # && is performed first => x
x or y and nil # evaluated left-to-right => nil

Comment:
The return values shown in the comments are not necessarily correct.

First expression "x || y && nil"
If x = false and y = true, for example, the expression returns nil, which is not x (false). See also my comment for page 108 about "performed."

Second expression "x or y and nil".
If x = false and y = false, the expression returns false, not nil.

(
line1
line2
) end if expression

Comment:

Remove "end" as

(
line1
line2
) if expression

when 2 then "two" # Then keyword instead of newline

Comment:
In the comment, change "Then" to "then".

The Class class defines ===

Comment:
=== is defined by Module, not by Class.

<code>
# Compute 2006 U.S. income tax using case and Range objects
tax = case income
when 0..7550
income * 0.1
when 7550..30650
755 + (income-7550)*0.15
when 30650..74200
4220 + (income-30655)*0.25
when 74200..154800
15107.5 + (income-74201)*0.28
when 154800..336550
37675.5 + (income-154800)*0.33
else
97653 + (income-336550)*0.35
end
</code>

Comment:
Check the numbers. For example,

4220 + (income-30655)*0.25
30655 should be 30650

15107.5 + (income-74201)*0.28
74201 should be 74200

while line=gets.chomp do # Loop, asking the user for input each time
case line
when /^\s*#/ # If input looks like a comment...
next # skip to the next line.
when /^quit$/i # If input is "quit" (case insensitive)...
break # exit the loop.
else # Otherwise...
puts line.reverse # reverse the user's input and print it.
end
end

Comment:
The line
next # skip to the next line.
is indented by 4 spaces from the previous line. It should be indented by 2 spaces.

In general, n.upto(m) runs its block m-n+1 times.

Comment:
Need to explain what happens if m < n.

Line 1: 4.upto(6) {|x| print x} # => prints "456"
Line 9: 3.times {|x| print x } # => prints "012"

Comment:
On Line1, there is no space between x and }.
On Line 9, there is a space between x and }.
There are numerous style inconsistencies of this kind in this book.

So, to pass an array enumerator to a method rather than the array itself, you can simply call the each method:

Comment:
This should read:

So, to pass a string enumerator to a method rather than the string itself, you can simply call the each_char method:

a.each {|x| puts "#{x},#{a.shift}" } # prints "1,1\n3,2\n5,3"

Comment:
Add \n after 5,3 so the code looks

a.each {|x| puts "#{x},#{a.shift}" } # prints "1,1\n3,2\n5,3\n"

5.4 Blocks

Comment:
Since 2.2.1 (page 35) says "There are two kinds of blocks in Ruby programs.", add a footnote to explain "blocks" here refer to formal blocks.

they are otherwise much like method parameters (see ?5.4.5 for details):

Comment:
?5.4.4 is a better sub-section to refer to because it begins with "We?ve said previously that the parameters to a block are much like the parameters to a method."

five do |head, *body, tail| # Extra values go into body array
print head, body, tail # Prints "1[2,3,4]5"
end

Comment:
With Ruby 1.9.2, "1[2, 3, 4]5" is printed (There is a space after 2, and 3,).

Figure 5-2.

Comments:
|y| should be inside the "block" box.

Also for ease of understanding,
Arrow 1 should start at "iterator" of z = x.iterator,
Arrow 2 should point to the top part of the "block" box.

The eval in both examples should use double quotes instead of parenthesis: puts eval "line"

Otherwise it generates an error: in `eval': undefined local variable or method `test' for main:Object (NameError)

This might work fine in 1.8, but in 1.9.3...it failed.

Great book BTW.

Figure 5-3.

Comments:
|y| should be inside the "block" box.

Also for ease of understanding,
Arrow 1 should start at "iterator" of z = x.iterator,
Arrow 2 should point to the top part of the "block" box.

Figure 5-4.

Comments:
|y| should be inside the "block" box.

Also for ease of understanding,
Arrow 1 should start at "iterator" of z = x.iterator,
Arrow 2 should point to the top part of the "block" box.

Sample code for throw and catch

Comment:
Right before this sample code, you write "it is best to consider throw and catch as a general-purpose (if perhaps infrequently used) control structure rather than an exception mechanism" but this sample code demonstrates handling an unexpected circumstance - the value of an element of a matrix is missing - for which the exception mechanism with raise and rescue is probably more suited.

The return value of catch can help you distinguish normal completion of the block from abnormal completion with throw,

Comment:
Since throw and catch are a general-purpose control structure, throw doesn't necessarily mean "abnormal" completion.

Comment:
factorial(0) should not raise an exception, since 0! = 1 by convention in mathematics. Change the code and text as follows:

Page 157

def factorial(n) # Define a factorial method with argument n
raise "bad argument" if n < 0 # Raise an exception for bad n
return 1 if n == 0 # factorial(0) is 1
n * factorial(n-1) # Compute other factorials recursively
end


raise RuntimeError, "bad argument" if n < 0
raise RuntimeError.new("bad argument") if n < 0
raise RuntimeError.exception("bad argument") if n < 0


raise ArgumentError if n < 0

raise ArgumentError, "Expected argument >= 0. Got #{n}" if n < 0


Page 158

if n < 0
raise ArgumentError, "Expected argument >= 0. Got #{n}", caller
end


Ruby compares the argument n to the integer 0 with the < operator.

Recall that the factorial method we defined earlier can raise ArgumentError or TypeError. Here?s how we would write a rescue clause to handle exceptions of either of these types and assign the exception object to the variable error:

rescue ArgumentError, TypeError => error

Comment:
As explained on page 158, the factorial method can raise NoMethodError as well. So the paragraph should be updated to:

Recall that the factorial method we defined earlier can raise ArgumentError, TypeError, or NoMethodError. Here?s how we would write a rescue clause to handle exceptions of any of these types and assign the exception object to the variable error:

rescue ArgumentError, TypeError, NoMethodError => error

Comment:
The paragraph and the code that follows should be updated to cover NoMethodError as well. The code should look:

begin
x = factorial(1)
rescue ArgumentError => ex
puts "Try again with a value >= 1"
rescue TypeError, NoMethodError => ex
puts "Try again with an integer"
end

BEGIN {
puts "if"; # This will be printed
a = 4; # This variable only defined here
}

Comment:
Remove unnecessary semicolons as

BEGIN {
puts "if" # This will be printed
a = 4 # This variable only defined here
}

if (false)

Comment:
Remove unnecessary parentheses as

if false

a = 4;
if (true)
END { # This END is executed
puts "if"; # This code is registered
puts a # The variable is visible; prints "4"
}
else

Comment:
Remove unnecessary parentheses and semicolons as

a = 4
if true
END { # This END is executed
puts "if" # This code is registered
puts a # The variable is visible; prints "4"
}
else

Fibers and their callers can exchange data through the arguments and return values of resume and yield.

Comment:
yield -> Fiber.yield

f = g = nil

f = Fiber.new {|x| # 1:
...
}

g = Fiber.new {|x| # 8:
...
}

Comment:
It is not necessary to initialize f with nil. To follow the common convention (page 141), use do/end, instead of curly braces, to delimit the blocks. The result should look:

g = nil

f = Fiber.new do |x| # 1:
...
end

g = Fiber.new do |x| # 8:
...
end

the caller uses resume and the fiber uses yield.

Comment:
yield -> Fiber.yield

JRuby, the Java-based implementation

Comment:
The word "JRuby" is used without a qualification at line 8 on the previous page. So the explanation "the Java-based implementation" should be attached to "JRuby" on the previous page. Or remove it because JRuby explained on page 12.

In the factorial method, that last expression will either be 1 or n*factorial(n-1).

Comment:
In the factorial method, the last (and only) expression is the "if" statement. 1 or n*factorial(n-1) is a sub-expression "if" evaluates.

that cover method names, method parentheses, and method arguments in more detail.

Comment:
method arguments -> method parameters

Note the 8th line from the bottom on the previos page (p.176) reads:

covering methods names, method parentheses, and method parameters.

The following code, using the sum method defined above, prints 4, but issues a warning in Ruby 1.8:
puts sum 2, 2

Comment:
Tried this with Ruby 1.8.7 but didn't see a warning.

How to declare an argument that has a default value, so that the argument can be omitted when the method is invoked

Comment:
an argument that has a default value
-> a parameter that has a default value

Arguments n, m, and c are passed as keys in a hash,

Comment:
It is more accurate to say "Arguments n, m, and c are passed as values associated with keys in a hash," or simply,
"Arguments n, m, and c are passed as hash values,"

def test
puts "entering method"
p = lambda { puts "entering lambda"; return }
p.call # Invoking the lambda does not make the method return
puts "exiting method" # This line *is* executed now
end
test

Comment:
For the name of the variable that refers to the lambda, it's better to use "l" like in the next sample program.

p.call(1) # x,y=1: nil used for missing rvalue: Prints 1nil

Comment:
Ruby 1.9.3 prints just "1", not "1nil".

from:
module Functional
.... omission....
# Example:
# product = lambda {|x,y| x*y}
# doubler = lambda >> 2 <== here

to:
module Functional
.... omission....
# Example:
# product = lambda {|x,y| x*y}
# doubler = product >> 2 <== here

double = lambda {|x| product(2,x) }

should be

double = lambda {|x| product[2,x] }

The call to self.instance_eval is not needed here. The following code works just fine with Ruby 2.1:

class Module
def []=(symbol, f)
define_method(symbol, f)
end
end


Enumerable[:average] = lambda do
puts "average"
end

[1].average

The code in the book is:

# Define [] method to allow a Point to look like an array or
# a hash with keys :x and :y
def [](index)
case index
when 0, -2: @x # Index 0 (or -2) is the X coordinate
when 1, -1: @y # Index 1 (or -1) is the Y coordinate
when :x, "x": @x # Hash keys as symbol or string for X
when :y, "y": @y # Hash keys as symbol or string for Y
else nil # Arrays and hashes just return nil on bad indexes
end
end

Using a colon instead of "then" doesn't work any more in Ruby 1.9.
The code should be:

# Define [] method to allow a Point to look like an array or
# a hash with keys :x and :y
def [](index)
case index
when 0, -2 then @x # Index 0 (or -2) is the X coordinate
when 1, -1 then @y # Index 1 (or -1) is the Y coordinate
when :x, "x" then @x # Hash keys as symbol or string for X
when :y, "y" then @y # Hash keys as symbol or string for Y
else nil # Arrays and hashes just return nil on bad indexes
end
end

super doesn't just look at superclasses for chaining. It can also chain to methods inherited from modules. And a singleton method defined on an object can use super to chain to an instance method defined by the class of the object.

To mix a module into a class, use include.

Comment:
This "include" should have an entry in the Index section of the book.

The sentence: "The eigenclass of an ordinary object stands alone and has no superclass" is not correct. The description of method lookup in this section is correct, but the details about superclasses of eigenclasses strays into messy implementation-dependent behavior.

See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/336490 for some discussion.

In the part about the method_added hook, it is said:

(...) there is no way to tell whether the named method was added to the class that defines method_added or whether it was added to a subclass of this class.

Next, a workaround solution for this problem is given. But in fact no workaround is needed - the class to which the new method was added is stored in self when inside the hook method. A simple code to demonstrate it:

class A;def A.method_added(m);p [self,m];end;end
class B<A;end
class A;def q;end;end # prints [A, :q]
class B;def w;end;end # prints [B, :w]

... so there is no way to tell whether the named method was added to the class that defines method_added or whether it was added to a subclass of that class.

One can solve the problem changing the code in this way:

def String.method_added(name)
puts "New instance method #{name} added to #{self} "
end

On the line which reads

1.upto(5) { |i| after i { puts i } }

A "undefined method `i'" error is occurring. It should be either

1.upto(5) { |i| after(i) { puts i } }

or

1.upto(5) { |i| after i do puts i end }

to avoid the second nested block binding to the `i' instead of `after'

The nitems method of Array has been removed in Ruby 1.9.

Delete the following two lines:

[1,2,nil].nitems # => 2: number of non-nil elements

TEXT WITH ERROR ---------

The == operator is the most common way to test for equality. In the Object class, it is simply a synonym for equal?, and it tests whether two object references are identical. Most classes redefine this operator to allow distinct instances to be tested for equality: a = "Ruby" # One String object b = "Ruby" # A different String object with the same content a.equal?(b) # false: a and b do not refer to the same object a == b # true: but these two distinct objects have equal values

---------

These two blocks of text seem to be at odds with each other. One says that == is a synonym for equal? but the other clearly shows that the two operators return different values when applied to the same two objects