Comments on Programming Scala

Comment on 'Linearization of an Object’s Hierarchy'

2009-07-17T09:41:07-07:00

Linearization of an Object’s Hierarchy

All our classes and traits define the method m. The one in C3 is called first, since the instance is of that type. C3.m calls super.m, which resolves to T3.m. The search appears to be “breadth-first”, rather than “depth-first”. (If it were depth-first, it would invoke C1.m after T3.m.) After, T3.m, T2.m, then T1.m, and finally C1.m are invoked. C1 is the parent of the three traits. From which of the traits did we traverse to C1? Let’s modify our first example and see how we got to C1.

Saying it's breadth-first is misleading, IMHO. It is actually depth first, with a twist: it leaves off handling each node for as late as possible. So, you could say that it does examine C1 after T3, but does not handle it, since it will have the opportunity to visit it from T1 later.

The distinction is very clear if you insert an additional layer of traits, T1B, T2B and T3B, between T1-3 and C2 (meaning, T1B extends T1, etc., and C2 extends T1B with T2B with T3B. Then the order of invocation will be C2, T3B, T3, T2B, T2, T1B, T1, C1. So, basically it's depth first, with the modification as noted above.

I know you specify the full algorithm below, but you never repudiate the "breadth-first" claim, and some people may be left with a misconception.
— glebfrank (2009-07-17 09:41:07)

Comment on 'Classes and Objects: Where Are the Statics?'

2009-07-12T21:01:51-07:00

Classes and Objects: Where Are the Statics?

Another benefit of package objects is that it provides a more succinct implementation of what was an awkward idiom before. Without package objects, you would have to put definitions in an ad hoc object inside the desired package, then import from the object. For example, here is how List would have to be handled without a package object.

Can you explain how this awkward idiom is needed?
— ctran (2009-07-12 21:01:51)

Comment on 'Linearization of an Object’s Hierarchy'

2009-07-05T06:58:15-07:00

Linearization of an Object’s Hierarchy

Scala inserts the ScalaObject trait as the last mixin, just before AnyRef and Any that are the penultimate and ultimate parent classes of any reference type. Of course, these three types do not show up in the output of the scripts, because we used an ad hoc m method to figure out the behavior by building up an output string.

Thx.
— deanwampler (2009-07-05 06:58:15)

Comment on 'The Scala Type Hierarchy'

2009-07-05T06:51:48-07:00

The Scala Type Hierarchy

Table 7.4. Direct and indirect subtypes of AnyRef, the reference types.

Name	Parent	Description
`Collection[+T]`	`Iterable[T]`	Trait for collections of known size.
`Either[+T1, +T2]`	`AnyRef`	Used most often as a return type when a method could return an instance of one of two unrelated types. For example, an exception or a “successful” result. The `Either` can be pattern matched for its `Left` or `Right` subtypes. (It is analogous to `Option`, with `Some` and `None`) For the exception-handling idiom, it is conventional to use `Left` for the exception.
`FunctionN[-T`₁`, -T`₂`, …, -T`_N`, +R]`	`AnyRef`	Trait representing a function that takes `N` arguments, each of which can have its own type, and returns a value of type `R`. (Traits are defined for `N` = 0 to 22.) The variance annotations (‘+’ and ‘-’) in front of the types will be explained in the section called “Variance Under Inheritance” in Chapter 12, The Scala Type System.
`Iterable[+T]`	`AnyRef`	Trait with methods for operating on collections of instances. Users implement the abstract `elements` method to return an `Iterable` instance.
`List[+T]`	`Seq[T]`	`sealed abstract class` for ordered collections with functional-style list semantics. It is the most widely-used collection in Scala, so it is defined in the `scala` package, rather than one of the collection packages. (In Scala version2.8, it is actually defined in `scala.collection.immutable` and “aliased” in `package object scala`). It has two subclasses, `case object Nil`, which extends `List[Nothing]` and represents an empty list, and `case final class ::[T]`, which represents a non-empty list, characterized by a head element and a tail list, which would be `Nil` for a one-element list.
`Nothing`	all other types	`Nothing` is the subtype of all other types. It has no instances. It is used primarily for defining other types in a type-safe way, such as the special `List` subtype `Nil`. See also the section called “Nothing and Null” in Chapter 12, The Scala Type System.
`Null`	all reference types	`Null` has one instance, `null`, corresponding to the runtime’s concept of `null`.
`Option[T]`	`Product`	Wraps an optional item. It is a `sealed abstract` type and the only allowed instances are an instance of its derived `case class Some[T]`, wrapping an instance of `T`, or its derived `case object None`, which extends `Option[Nothing]`.
`Predef`	`AnyRef`	An `object` that defines and imports many commonly-used types and methods. See the section called “The Predef Object” earlier in this chapter for details.
`Product`	`AnyRef`	Trait with methods for determining arity and getting the n^th item in a “cartesian product”. Subtraits are defined for `Product`, called `ProductN`, for dimension `N` from 1 through 22.
`ScalaObject`	`AnyRef`	Mixin trait added to all Scala reference type instances.
`Seq[+T]`	`Collection[T]`	Trait for ordered collections.
`TupleN`	`ProductN`	Separate case classes for arity `N` = 1 through 22. Tuples support the literal syntax `(x1, x2, …, xN)`.

Fixed. Thx.
— deanwampler (2009-07-05 06:51:48)

Comment on 'Sealed Class Hierarchies'

2009-07-05T06:47:06-07:00

Sealed Class Hierarchies

This script outputs the following.

Doh! Copy & paste ...
— deanwampler (2009-07-05 06:47:06)

Comment on 'The Predef Object'

2009-07-05T06:34:01-07:00

The Predef Object

Briefly, a Pair[A2,B2], for some A2 and B2, is a subclass of Pair[A1,B1], for some A1 and B1, if A2 is a subtype of A1 and B2 is a subtype of B1. In the section called “Understanding Parameterized Types” in Chapter 12, The Scala Type System, we’ll discuss ‘+’ and other type qualifiers in more detail.

Thanks. Will fix
— deanwampler (2009-07-05 06:34:01)

Comment on 'Linearization of an Object’s Hierarchy'

2009-06-22T00:16:03-07:00

Linearization of an Object’s Hierarchy

we used an our <- ad hoc m method
— robcd (2009-06-22 00:16:03)

Comment on 'Sealed Class Hierarchies'

2009-06-21T23:59:12-07:00

Sealed Class Hierarchies

This script outputs the following.

only need 'case Connect(body) =>' in def handle, in Ex 7.7, 7.8
— robcd (2009-06-21 23:59:12)

Comment on 'The Scala Type Hierarchy'

2009-06-21T14:35:10-07:00

The Scala Type Hierarchy

Table 7.4. Direct and indirect subtypes of AnyRef, the reference types.

Name	Parent	Description
`Collection[+T]`	`Iterable[T]`	Trait for collections of known size.
`Either[+T1, +T2]`	`AnyRef`	Used most often as a return type when a method could return an instance of one of two unrelated types. For example, an exception or a “successful” result. The `Either` can be pattern matched for its `Left` or `Right` subtypes. (It is analogous to `Option`, with `Some` and `None`) For the exception-handling idiom, it is conventional to use `Left` for the exception.
`FunctionN[-T`₁`, -T`₂`, …, -T`_N`, +R]`	`AnyRef`	Trait representing a function that takes `N` arguments, each of which can have its own type, and returns a value of type `R`. (Traits are defined for `N` = 0 to 22.) The variance annotations (‘+’ and ‘-’) in front of the types will be explained in the section called “Variance Under Inheritance” in Chapter 12, The Scala Type System.
`Iterable[+T]`	`AnyRef`	Trait with methods for operating on collections of instances. Users implement the abstract `elements` method to return an `Iterable` instance.
`List[+T]`	`Seq[T]`	`sealed abstract class` for ordered collections with functional-style list semantics. It is the most widely-used collection in Scala, so it is defined in the `scala` package, rather than one of the collection packages. (In Scala version2.8, it is actually defined in `scala.collection.immutable` and “aliased” in `package object scala`). It has two subclasses, `case object Nil`, which extends `List[Nothing]` and represents an empty list, and `case final class ::[T]`, which represents a non-empty list, characterized by a head element and a tail list, which would be `Nil` for a one-element list.
`Nothing`	all other types	`Nothing` is the subtype of all other types. It has no instances. It is used primarily for defining other types in a type-safe way, such as the special `List` subtype `Nil`. See also the section called “Nothing and Null” in Chapter 12, The Scala Type System.
`Null`	all reference types	`Null` has one instance, `null`, corresponding to the runtime’s concept of `null`.
`Option[T]`	`Product`	Wraps an optional item. It is a `sealed abstract` type and the only allowed instances are an instance of its derived `case class Some[T]`, wrapping an instance of `T`, or its derived `case object None`, which extends `Option[Nothing]`.
`Predef`	`AnyRef`	An `object` that defines and imports many commonly-used types and methods. See the section called “The Predef Object” earlier in this chapter for details.
`Product`	`AnyRef`	Trait with methods for determining arity and getting the n^th item in a “cartesian product”. Subtraits are defined for `Product`, called `ProductN`, for dimension `N` from 1 through 22.
`ScalaObject`	`AnyRef`	Mixin trait added to all Scala reference type instances.
`Seq[+T]`	`Collection[T]`	Trait for ordered collections.
`TupleN`	`ProductN`	Separate case classes for arity `N` = 1 through 22. Tuples support the literal syntax `(x1, x2, …, xN)`.

The second line for the description for List[+T] has a typo. scala pacakge -> scala package
— pgdad (2009-06-21 14:35:10)

Comment on 'The Predef Object'

2009-06-21T12:32:31-07:00

The Predef Object

'Typle[Ay, By] itself is a derived type of Typle[Ax, Bx]' should be 'Tuple2[Ay, By] ... Tuple2[Ax, Bx]'
— robcd (2009-06-21 12:32:31)