...in which we remove some boilerplate from a function invocation by introducing placeholder syntax.

...in which we examine the ups and downs of multiple variable assignment in Scala.

...in which we look at the impact of a class member's surroundings on its initialization.

...in which we follow a couple of abstract and overridden values through the class initialization order.

...in which we attempt to size up a couple of collections without worrying too much about their exact type.

...in which we try to be good functional citizens by defining generic versions of two type-specific helper functions.

...in which we catch a late glimpse at an indexed data sequence through a couple of delayed accessor functions.

...in which we transform some alphabet soup using a for comprehension and an application of map.

...in which we define and randomly access one of a pair of mutually referential variables.

...in which we mix some debugging code into a case class's hashCode method.

...in which we try to initialize a lazy value in changing circumstances.

...in which we try our hand at printing Roman numerals in order of value.

...in which we see how Scala handles self-referential variables.

...in which we experiment with program control flow.

...in which we invoke two partially applied functions as a counter keeps on ticking.

...in which we provide varying numbers of arguments in a partial function application.

...in which we create a partially applied function from a method with implicit parameters.

...in which we define and call overloaded methods with varying numbers of parameters.

...in which we call a method with and without specifying the names of the arguments.

...in which we remove some debugging code from a regex match.

...in which we pad a string to a desired length, one '*' character at a time.

...in which we work with a map returned from a call to Java code by (gulp!) casting it to a Scala-typed map.

...in which we instantiate multiple instances of a class whose constructor specifies a by-name parameter.

...in which we sort a couple of arrays of Doubles.

...in which we combine two lists and get a little confused when trying to extract an element from the result.

...in which we refactor a method to use multiple parameter lists while forgetting to change the code that calls the method.

...in which we apply a pattern match to a string coming from a call to Java code.

...in which we initialize an AnyVal subtype whose specific type is declared in a subclass.

...in which we import additional implicits to create a 'test mode' context halfway through our program.

...in which we define two implicit conversions, letting the compiler figure out the return type of one of them.

...in which we optimize a map call that only operates on the value of Map entries.

...in which we convert a list into a set before adding an additional element.

...in which we use two different ways to specify a default value for map entries.

...in which we refactor an ''old skool'' object with an explicit main method by modifying it to extend the App trait.

...in which we use parentheses and curly braces to define an anonymous function.

...in which we refactor a counting method to handle general collection types.