Errata

The second example is missing the double semi-colon. It should be:

> // Introduce two values
let x = 1
let y = 2.3;;

val x : int
val y : float
...

(I actually get slightly different output from the Visual Studio 2010 Beta, but I guess that is a post-printing change)

Note from the Author or Editor:
The text:

val x : int
val y : float

Needs to be updated to:

val x : int = 1
val y : float = 2.3

val main : string array -> int
should be:
val main : string [] -> int

maybe F# 2.0 syntax changed.

Note from the Author or Editor:
Yup, thank you for your feedback.

book says:
> let answerToEverything = 42UL;;
val everything : uint64 = 42UL

should say:
> let answerToEverything = 42UL;;
val answerToEverything = 42UL;;

Note from the Author or Editor:
Yes, the code:

val everything : uint64 = 42UL

should be replaced with:

val answerToEverything : uint64 = 42UL

avogadro number is the number of atoms in a mole, so the exponent is non negative.

Errata:
avogadro = 6.022e-23;;
correct
6.022e23;;

Note from the Author or Editor:
I should have paid more attention in chemistry class :)

The text on page 14 should be changed:

... > let avogadro = 6.022e-23;; ...
to
... > let avogadro = 6.022e23;; ...

and

...val avogadro : float = 6.022e-23 ...
to
...val avogadro : float = 6.022e+23 ...

uint, uint32 u System.UInt32
should be:
uint32 u System.UInt32

In F# 2.0, The type 'uint' is not defined.

Note from the Author or Editor:
Yup. I don't recall when we removed this from the core F# library.

float32 f System.Float
should be:
float32 f System.Single

System.Float is not a .NET type.
System.Single is the intended type.

Note from the Author or Editor:
This has been since been fixed.

uint32, uint Converts data to a uint
should be:
uint32 Converts data to a uint32

In F# 2.0, The type 'uint' is not defined.

Note from the Author or Editor:
In table 2-4 the row which reads:

uint32, uint // uint 0xFF // 255

Should read:

uint32 // uint 0xFF // 255

In F# 2.0, The type 'BigInt' is not defined, so:

Section title
BigInt
should be:
bigint

F# has the BigInt type for representing arbitrarily large integers.
should be:
F# has the bigint type for representing arbitrarily large integers.

While the BigInt type is simply an alias for the System.Numerics.BigInteger type,
should be:
While the bigint type is simply an alias for the System.Numerics.BigInteger type,

BigInt uses the I suffix for literals. Example 2-1 defines data storage sizes as BigInts.
should be:
bigint uses the I suffix for literals. Example 2-1 defines data storage sizes as bigints.

Example 2-1. The BigInt type for representing large integers
should be:
Example 2-1. The bigint type for representing large integers

Note from the Author or Editor:
Yes, there are a lot of other places (also reported) that need to replace BigInt with bigint.

stdin(3,5): error FS0001: This expression has type
float
but is here used with type
int.

now is:

Stdin(3,5): error FS0001: This expression was expected to have type
int
but here has type
float

F# 2.0's error message more clearly.

Note from the Author or Editor:
The code example on page 23 under "Type Inference" should be replaced with the following (only updates the last three lines):

> add 1.0 2.0;;

add 1.0 2.0;;
----^^^

stdin(3,5): error FS0001: This expression was expected to have type
int
but here has type
float

stdin(118,19): error FS0001: This expression has type
string
but is here used with type
int.
stopped due to error

should be:

stdin(118,19): error FS0001: This expression was expected to have type
int
but here has type
string

F# 2.0's error message more clearly.

Note from the Author or Editor:
Yup, the error message in the text is from an earlier version of F#.

Example 3-3 does not work as-is in VS 2010. "base" is apparently a keyword, so it should have been escaped or there is some voodoo to make it not a keyword that I've missed in the book. Line 2 of the example should look like this:

let generatePowerOfFunc ``base`` = (fun exponent -> ``base`` ** exponent);;

Alternatively, a different variable name should be chosen.

Note from the Author or Editor:
Thanks for the feedback, I must have missed the keyword being marked as reserved late in the product cycle.

In a future version of the book I'll have it read:

let generatePowerOfFunc baseValue = (fun exponent -> baseValue ** exponent);;

Possible mistake in the line

> let (~+++) x y z = x + y + z;;

let (~+++) x y z = x + y + z;;
-----^^^^

stdin(27,6): error FS1208: Invalid operator definition. Prefix operator definitions must use a valid prefix operator name.

I suspect this may be due to the rules governing valid operators apparently having changed prior to the language's final release:-

http://stackoverflow.com/questions/2304120/f-what-are-the-valid-prefix-operators

Note from the Author or Editor:
Yes, you are correct. As linked in that StackOverflow post, a more recent version of the F# spec (April, 2010) is online at:
http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html

This will get updated in a future printing.

The two references to Seq.tolist on pages 82 and 83 should be Seq.toList.

Note from the Author or Editor:
On page 82 at the bottom of the paragraph "... uses the Seq.tolist function" should read "... uses the Seq.toList function" (with a capitol L).

Similarly, on page 83 "> Seq.tolist fibsUnder100;;" should read "> Seq.toList fibsUnder100"

val x : int array = [|0|]
val y : int array = [|0|]
val it : int array = [|3|]
val it : int array = [|3|]

should be:

val x : int [] = [|0|]
val y : int [] = [|0|]
val it : int [] = [|3|]
val it : int [] = [|3|]

maybe F# 2.0 syntax changed.

val it : float array
val emptyIntArray : int array
val emptyStringArray : string array

should be:

val it : float []
val emptyIntArray : int []
val emptyStringArray : string []

Note from the Author or Editor:
Yup, thanks for your feedback.

val vowels : char array
should be:
val vowels : char []

Note from the Author or Editor:
On page 99, the code example with text:

val vowels : char array

Should replaced with the following:

val vowels : char []

Errata error listed for page 132 ... is actually on page 125.

Replacing 'new Point()' with 'new Point3()'

The constructors should be calling type Point3 and not Point.

"new() = new Point(0.0, 0.0)" should be replaced with:
"new() = new Point3(0.0, 0.0)".

And later in the example "new Point(x, y)" should be replaced with:
"new Point3(x, y)".

Note from the Author or Editor:
The constructors should be calling type Point3 and not Point.

"new() = new Point(0.0, 0.0)" should be replaced with:
"new() = new Point3(0.0, 0.0)".

And later in the example "new Point(x, y)" should be replaced with:
"new Point3(x, y)".

In the warning slice the list of binary operators that support other CLI languages don't include: <,<=,>,>=,=,<> and this operators are supported on the CLI as well.

For example given the code:

type Foo(power) =
member public x.Power
with get() = power
static member public (<=) (a : Foo, b : Foo) =
a.Power <= b.Power

The F# 2.0 compiler will throws a warnings like the following.

Warning 1 The name '(<=)' should not be used as a member name. To define comparison semantics for a type, implement the 'System.IComparable' interface. If defining a static member for use from other CLI languages then use the name 'op_LessThanOrEqual' instead.

If you check the IL object code from the C# point of view you get:

public static bool operator <=(Bar.Foo a, Bar.Foo b)
{
return LanguagePrimitives.HashCompare.GenericLessOrEqualIntrinsic<IComparable>(a.Power, b.Power);
}

Note from the Author or Editor:
Noted.

'min' should be replaced with 'max' in the following line of code:

m_amountLeft <- min (m_amountLeft - amount) 0.0<ml>

otherwise the cup gets empty whenever the method Drink is called

Note from the Author or Editor:
Yes, the code example should be updated to read:

m_amountLeft <- max (m_amountLeft - amount) 0.0<ml>

Characters other than . $ { [ ( | ) ] } * + ? are matched verbatim.
should be:
Characters other than . $ { [ ( | ) ^ \ * + ? are matched verbatim.

Used to escape metacharacters, such as matching . $ { [ ( | ) ] } * + ?
should be:
Used to escape metacharacters, such as matching . $ { [ ( | ) ^ \ * + ?

Note from the Author or Editor:
The poster said it all, thanks.

let tagPairs = new Regex(@"\[(^\])+\]")
let comments = new Regex(@"\{(^\})+\}")

should be:

let tagPairs = new Regex(@"\[[^\]]+\]")
let comments = new Regex(@"\{[^\}]+\}")

Note from the Author or Editor:
Noted.

List.tl is used to skip the first group?s value
should be:
List.tail is used to skip the first group?s value

match (List.tl [ for g in result.Groups -> g.Value ]) with
should be:
match (List.tail [ for g in result.Groups -> g.Value ]) with

In F# 2.0, List.tl changed to List.tail

friendlier library in System.Linq.XML.dll which will be covered here.
should be:
friendlier library in System.Xml.Linq.dll which will be covered here.

Note from the Author or Editor:
Doh, sorry about that.

if Map.contains word acc then
should be:
if Map.containsKey word acc then

Note from the Author or Editor:
Yup, the code in the middle of the page which reads:

if Map.contains word acc then

should be:

if Map.containsKey word acc then