## F# Fridays and Scala Saturdays

I’ve decided to take a page out of Steven Proctor‘s book–well, blog actually. He has been doing Ruby Tuesday, a weekly series of posts on Ruby. Each week he examines a certain function in the language. He also publishes a counterpart series, Erlang Thursday, in which he does the same thing in—you guessed it—APL.

Kidding. It’s Erlang, of course.

The nice thing about these series is that Proctor examines the same or similar features in both languages. You get to see the application of a concept in Ruby, and then a couple of days later, the same concept in Erlang. It’s interesting to note the similarities and differences in the two languages.

In like fashion, I am beginning two series: F# Friday and Scala Saturday. I’ll probably borrow (i.e., steal blind) a number of Proctor’s ideas, that is, cover the same sort of functions he has. I thank Mr. Proctor for the idea and Mrs. Ezell, my middle school grammar teacher, for alliteration.

## FPOO Chapter 6 in Scala

This is the second in a series of articles working though the exercises in Brian Marick’s Functional Programming for the Object-Oriented Programmer, but implemented in Scala instead of Clojure. (Hat tip to Mr. Avdi Grimm for the idea.) The full source code is available on GitHub. Read the previous article on the exercises in chapter 1.

### Exercise 1: Factorial

We did a factorial function in chapter 1, but Mr. Marick introduces us to recursion in chapter 6. Therefore we’ll use recursion in this implementation, in particular, recursion that uses the following form:

```def factorial(n: Int): Int = n match {
case endingCase => endingValue(n)
case _ => combine(n, factorial(smallerValFromN(n)))
}
```

As with last time, the test first using the table-driven method:

```class FactorialSpec extends UnitSpec with TableDrivenPropertyChecks {
"Chapter 6, Exercise 1: factorial" should "compute the factorial, i.e., n!, of a given integer n >= 0" in {
val factorials = Table(
("n", "fact"),
(0,   1),
(1,   1),
(2,   2),
(3,   6),
(4,  24),
(5, 120)
)

forAll (factorials) { (n: Int, fact: Int) =>
whenever (n >= 0) {
factorial(n) should be (fact)
}
}
}
}
```

… and now the implementation:

```object Chapter06 {
def factorial(n: Int): Int = n match {
case 0 => 1
case _ => n * factorial(n - 1)
}
}
```

In one of Mr. Marick’s hints, he suggests not worrying about the zero case, but it’s easy enough. Another case to handle is a negative `n`, which I handled in the exercises for chapter 1, but decided not to bother with this time.

### Exercise 2: A Second Factorial

Yet another implementation of factorial, but this time we use a slightly different recursive form:

```def factorial(n: Int): Int = {
def factorialAcc(n: Int, soFar: Int) = n match {
case endingCase => soFar
case _ => factorialAcc(smallerValFromN(n), combine(n, soFar))
}
factorialAcc(n, 1)
}
```

My test is almost exactly the same as the test for Exercise #1:

```class Factorial2Spec extends UnitSpec with TableDrivenPropertyChecks {
"Chapter 6, Exercise 2: factorial2" should "compute the factorial, i.e., n!, of a given integer n >= 0" in {
val factorials = Table(
("n", "fact"),
(0,   1),
(1,   1),
(2,   2),
(3,   6),
(4,  24),
(5, 120)
)

forAll (factorials) { (n: Int, fact: Int) =>
whenever (n >= 0) {
factorial2(n) should be (fact)
}
}
}
}
```

The implementation using the second form of recursion is as follows:

```object Chapter06 {
def factorial2(n: Int): Int = {
@tailrec
def fact_(something: Int, soFar: Int): Int = something match {
case 0 => soFar
case _ => fact_(something - 1, something * soFar)
}
fact_(n, 1)
}
}
```

Two points about this form of recursion: First, this form uses an accumulator, a value that we use to build our way up to the final answer with each step of the recursion (in contrast to the first pattern, which piles up a stack of recursive calls until the end case, at which point we combine the return values of the entire stack). The `soFar` parameter of the `fact_` inner function serves as the accumulator in the implementation above.

Second, this form of recursion uses tail recursion, wherein the return value on the recursive branch is the recursive call and nothing else. The call to `fact_` in the recursive branch is called a tail call. The compiler can optimize tail recursion as a loop. As Mr. Marick informs us, in Clojure, one must employ the `recur` function to make tail call optimization happen. Similarly, Scala requires the `@tailrec` annotation, as highlighted above.

### Exercise 3: Summing a Sequence of Numbers

This exercise is to implement a function that sums the number of a sequence together using the second pattern of recursion, i.e., using a tail call with an accumulator. The test is as follows:

```class SumSequenceSpec extends UnitSpec {
"Chapter 6, Exercise 3: sumSequence" should "sum all of the elements in a sequence starting with an initial value" in {
sumSequence(Seq(2, 4, 6, 8), 0) should be (20)
}
it should "return 0 if the sequence is empty" in {
sumSequence(Seq[Int](), 0) should be (0)
}
}
```

… and the implementation:

```object Chapter06 {
@tailrec
def sumSequence[T](seq: Seq[T], init: T)(implicit n: Numeric[T]): T = seq match {
case Seq() => init
case _ => sumSequence(seq.tail, n.plus(init, seq.head))
}
}
```

This time, instead of using an inner function to do the recursion, `sumSequence` itself takes an accumulator, `init`. Consequently, I can annotate it with `@tailrec`. Also I employed the trick from the exercises in chapter 1 of using an implicit `Numeric` parameter to enforce the constraint that this only works for sequences of numbers.

### Exercise 4: Multiplying a Sequence of Numbers

The only difference between this exercise and the last one is the operation we perform on the sequence elements. Here’s the test:

```class ProdSequenceSpec extends UnitSpec {
"Chapter 6, Exercise 4: prodSequence" should "multiply all of the elements in a sequence starting with an initial value" in {
prodSequence(Seq(2, 4, 6, 8), 1) should be (384)
}
it should "return 1 if the sequence is empty" in {
prodSequence(Seq[Int](), 1) should be (1)
}
}
```

… and here’s the implementation:

```object Chapter06 {
@tailrec
def prodSequence[T](seq: Seq[T], init: T)(implicit n: Numeric[T]): T = seq match {
case Seq() => init
case _ => prodSequence(seq.tail, n.times(init, seq.head))
}
}
```

### Exercise 4a: Extracting the Combiner

Mr. Marick notes that the only difference between exercises 3 and 4 is the operation performed on the elements in the sequence, or the combiner, to borrow the parlance in Mr. Marick’s pseudocode. The test reflects the difference in the way we call the function now by passing in the combiner as a parameter with the sequence:

```class ReduceSequenceSpec extends UnitSpec {
val op = (a: Int, b: Int) => a * b
"Chapter 6, Exercise 4a: reduceSequence" should "apply an operation all of the elements in a sequence starting with an initial value" in {
reduceSequence(op, Seq(2, 4, 6, 8), 1) should be (384)
}
it should "return init if the sequence is empty" in {
reduceSequence(op, Seq[Int](), 1) should be (1)
}
}
```

And here is how I have implemented it:

```object Chapter06 {
@tailrec
def reduceSequence[A](op: (A, A) => A, seq: Seq[A], init: A): A = seq match {
case Seq() => init
case _ => reduceSequence(op, seq.tail, op(seq.head, init))
}
}
```

That works, but there is a problem. Exercise 5 exposes it.

### Exercise 5: Building a Map from a Sequence

Mr. Marick stresses that we should perform this next exercise without changing the implementation of `reduceSequence`. So let’s try with our test:

```class ReduceSequenceVecToMapSpec extends UnitSpec {
val op = (a: String, b: Map[String, Int]) => b + (a -> 0)
"Chapter 6, Exercise 5: reduceSequence" should "convert a sequence of strings into a map keyed to those strings with values of zero" in {
reduceSequence(op, Vector("a", "b", "c"), Map[String, Int]()) should be (Map("a" -> 0, "b" -> 0, "c" -> 0))
}
it should "return init if the sequence is empty" in {
reduceSequence(op, Seq[String](), Map[String, Int]()) should be (Map[String, Int]())
}
val op2 = (a: String, b: Map[String, Int]) => b + (a -> (b.size + 1))
"Chapter 6, Exercise 5a: reduceSequence" should "convert a sequence of strings into a map keyed to those strings with values that increment by 1" in {
reduceSequence(op2, Vector("a", "b", "c"), Map[String, Int]()) should be (Map("a" -> 1, "b" -> 2, "c" -> 3))
}
}
```

And now the error bites us. Clojure is dynamically typed, so the implementation we would have come up with in Clojure probably would still work for this exercise if it worked for the last one.

Scala, in contrast, is statically typed. Our implementation worked in the last exercise because the type of the elements in the input sequence is the same as the type of the return value: we’re taking a sequence of integers and multiplying/adding them together, which produces an integer. In this exercise, however, we need to take a sequence of strings and produce a map—ain’t nothin’ the same about them types there! Therefore the implementation has to change to allow for a return type different from the type of the input elements:

```object Chapter06 {
@tailrec
def reduceSequence[A, B](op: (A, B) => B, seq: Seq[A], init: B): B = seq match {
case Seq() => init
case _ => reduceSequence(op, seq.tail, op(seq.head, init))
}
}
```

That wraps up chapter 6. Exercises from later chapters to come in future posts.

## FPOO Chapter 1 in Scala

This is the first in a series of articles working though the exercises in Brian Marick’s Functional Programming for the Object-Oriented Programmer, but implemented in Scala instead of Clojure. (Hat tip to Mr. Avdi Grimm for the idea.) The full source code is available on GitHub.

For each exercise, I first wrote a specification in ScalaTest and then wrote the implementation. I followed the recommendation of the ScalaTest user guide and created the UnitSpec base class that all of my specs extend:

```class UnitSpec extends FlatSpec
with Matchers
with OptionValues
with Inside
```

### Exercise 1: second

First the test:

```class SecondSpec extends UnitSpec {
"Exercise 1: second" should "return the second item in a given list" in {
val list = List("Lorem", "ipsum", "dolor", "sit", "amet")
second(list) should be ("ipsum")
}
it should "throw IndexOutOfBoundsException if called on a list with fewer than 2 elements" in {
val listOf1 = List("sole")
a [IndexOutOfBoundsException] should be thrownBy {
second(listOf1)
}
}
}
```

… and then the implementation—pretty simple:

```object Chapter01 {
def second[A](list: List[A]): A = list(1)
}
```

### Exercise 2: third

Mr. Marick asked for two implementations. First the tests, then the implementations:

```class ThirdSpec extends UnitSpec {
"Exercise 2a: third" should "return the third item in a given list" in {
val list = List("Lorem", "ipsum", "dolor", "sit", "amet")
third(list) should be ("dolor")
}
it should "throw IndexOutOfBoundsException if called on a list with fewer than 3 elements" in {
val listOf2 = List("penultimate", "ultimate")
a [IndexOutOfBoundsException] should be thrownBy {
third(listOf2)
}
}

"Exercise 2b: third2" should "return the third item in a given list" in {
val list = List("Lorem", "ipsum", "dolor", "sit", "amet")
third2(list) should be ("dolor")
}
it should "throw NoSuchElementException if called on a list with fewer than 3 elements" in {
val listOf2 = List("penultimate", "ultimate")
a [NoSuchElementException] should be thrownBy {
third2(listOf2)
}
}
}
```

Again, both are pretty simple:

```object Chapter01 {
def third[A](list: List[A]): A = list(2)
def third2[A](list: List[A]): A = list.tail.tail.head
}
```

### Exercise 3: addSquares

The test for this one is pretty straightforward:

```class AddSquaresSpec extends UnitSpec {
"Exercise 3: addSquares" should "square each item in a list and sum them" in {
val list = List(1, 2, 5)
addSquares(list) should be (30)
}
it should "return 0 if called on an empty list" in {
val emptyList = List[Int]()
addSquares(emptyList) should be (0)
}
}
```

I found the implementation somewhat challenging because I was not sure how to limit my input parameter to be a list of numbers. A second argument list that takes a single implicit parameter did the trick:

```object Chapter01 {
def addSquares[T](list: List[T])(implicit n: Numeric[T]): T =
list.map( x => n.times(x, x) ).sum
}
```

### Exercise 4: bizarreFactorial

In order to have a list of several inputs and the expected result for each, I used ScalaTest’s TableDrivenPropertyChecks trait.

```class BizarreFactorialSpec extends UnitSpec with TableDrivenPropertyChecks {
"Exercise 4: bizarreFactorial" should "compute the factorial, i.e., n!, of a given integer n >= 0" in {
val factorials = Table(
("n", "factorial"),
(0,   1),
(1,   1),
(2,   2),
(3,   6),
(4,  24),
(5, 120)
)

forAll (factorials) { (n: Int, factorial: Int) =>
whenever (n >= 0) {
bizarreFactorial(n) should be (factorial)
}
}
}
}
```

Mr. Marick’s constraints were to use `apply`, but not to use either iteration or recursion. Scala has `apply`, but its purpose is to allow you to use an object as if it were a function. Clojure’s `apply` is effectively used more like the way Scala uses `reduce` on collections. Consequently, I could have implemented `bizarreFactorial` this way:

```object Chapter01 {
def bizarreFactorial(n: Int): Int = n match {
case x if x < 0 => throw new IllegalArgumentException("Factorial only works for positive integers")
case 0 => 1
case _ => 1 to n reduce (_ * _)
}
}
```

But Scala has a shorthand for that: `product` (like `sum` in Exercise 3 above), which yields slightly more readable code.

```object Chapter01 {
def bizarreFactorial(n: Int): Int = n match {
case x if x < 0 => throw new IllegalArgumentException("Factorial only works for positive integers")
case 0 => 1
case _ => 1 to n product
}
}
```

### Exercise 5: Other Functions

As this exercise required the demonstration of a handful of functions that Clojure already has defined, I was able to use the Scala analogues in most cases:

```class OtherFunctionsSpec extends UnitSpec {
"Exercise 5a: take" should "create a new sequence of the first n elements of an existing sequence" in {
1 to 10 take 3 should be (List(1, 2, 3))
}

"Exercise 5b: distinct" should "remove duplicates from an existing sequence" in {
val dupes = Seq(1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6)
dupes.distinct should be (1 to 6)
}

"Exercise 5c: ++" should "concatenate two sequences together" in {
val a = 1 to 3
val b = 4 to 6
a ++ b should be (1 to 6)
}

"Exercise 5d: fill" should "create a sequence containing n copies of the same value" in {
Seq.fill(5)(2) should be (Seq(2, 2, 2, 2, 2))
}

"Exercise 5e: interleave" should "interleave the elements of two sequences together" in {
val evens = 0 to 8 by 2
val odds = 1 to 9 by 2
evens interleave odds should be (0 to 9)
}

"Exercise 5f.i: drop" should "remove the first n items from the sequence" in {
1 to 10 drop 3 should be (4 to 10)
}
"Exercise 5f.ii: dropRight" should "remove the last n items from the sequence" in {
1 to 10 dropRight 3 should be (1 to 7)
}

"Exercise 5g: flatten" should "turn a sequence of sequences into a sequence containing all of the values of each subsequence" in {
Seq(1 to 3, 4 to 6, 7 to 9).flatten should be (1 to 9)
}

"Exercise 5h: grouped" should "yield an iterator that turns the given sequence into a sequence of subsequences, each n items long" in {
(1 to 9 grouped 3).toSeq should be (Seq(1 to 3, 4 to 6, 7 to 9))
}

"Exercise 5i: forall" should "test whether all items in a sequence meet a certain condition" in {
1 to 9 forall { _ < 10 } should be (true)
}

"Exercise 5j: filterNot" should "remove items meeting a certain criterion from a given sequence" in {
1 to 10 filterNot { _ % 3 == 0 } should be (Seq(1, 2, 4, 5, 7, 8, 10))
}
}
```

Nevertheless, Clojure has one function `interleave` that Scala does not have out of the box, so I had to implement it myself as an extension method:

```object Chapter01 {
implicit class Ops[A](val seq: Seq[A]) extends AnyVal {
def interleave(that: Seq[A]): Seq[A] = {
(seq, that).zipped flatMap { Seq(_, _) }
}
}
}
```

### Exercise 6: prefixOf

```class PrefixOfSpec extends UnitSpec {
"Exercise 6: prefixOf" should "test whether a sequence consists of the first few elements of another sequence" in {
(1 to 3) prefixOf (1 to 10) should be (true)
}
}
```

Scala already has `startsWith`, but it seemed like cheating to use it to implement `prefixOf`:

```object Chapter01 {
implicit class Ops[A](val seq: Seq[A]) extends AnyVal {
def prefixOf(that: Seq[A]): Boolean = {
that startsWith seq
}
}
}
```

So I used `take`:

```object Chapter01 {
implicit class Ops[A](val seq: Seq[A]) extends AnyVal {
def prefixOf(that: Seq[A]): Boolean = {
(that take seq.length) == seq
}
}
}
```

### Exercise 7: tails

I came up with three implementations.

```class TailsSpec extends UnitSpec {
val seq = 1 to 4
val expected = Seq(1 to 4, 2 to 4, 3 to 4, 4 to 4, 4 until 4)
"Exercise 7a: tails1" should "return a sequence of successively smaller subsequences of the argument" in {
seq.tails1 should be (expected)
}
}
```

Scala already has an implementation of `tails` although it returns an iterator instead of a fully constructed sequence. Implementing the version of Mr. Marick’s `tails` function was no harder than calling `toSeq`:

```object Chapter01 {
implicit class Ops[A](val seq: Seq[A]) extends AnyVal {
def tails1: Seq[Seq[A]] = seq.tails.toSeq
}
}
```

But again, that seems like cheating, so my second implementation was my own.

```class TailsSpec extends UnitSpec {
val seq = 1 to 4
val expected = Seq(1 to 4, 2 to 4, 3 to 4, 4 to 4, 4 until 4)
"Exercise 7b: tails2" should "return a sequence of successively smaller subsequences of the argument" in {
seq.tails2 should be (expected)
}
}
```

The solution that first occurred to me was to use pattern matching and recursion:

```object Chapter01 {
implicit class Ops[A](val seq: Seq[A]) extends AnyVal {
def tails2: Seq[Seq[A]] = {
def tailn(s: Seq[A]): Seq[Seq[A]] = s match {
case Seq() => Seq(s)
case _ => s +: tailn(s.tail)
}
tailn(seq)
}
}
}
```

A perfectly valid implementation, and yet I wanted one more.

```class TailsSpec extends UnitSpec {
val seq = 1 to 4
val expected = Seq(1 to 4, 2 to 4, 3 to 4, 4 to 4, 4 until 4)
"Exercise 7c: tails3" should "return a sequence of successively smaller subsequences of the argument" in {
seq.tails3 should be (expected)
}
}
```

I took a peek at Mr. Marick’s Clojure implementation. I wanted to do a Scala version of it:

```object Chapter01 {
implicit class Ops[A](val seq: Seq[A]) extends AnyVal {
def tails3: Seq[Seq[A]] = {
val seqs = Seq.fill(seq.length + 1)(seq)
val nToDrop = 0 to seq.length
(seqs, nToDrop).zipped map (_ drop _)
}
}
}
```

Well, that’s all for Chapter 1. Look for my take on Chapter 2 to come soon. Chapters 2–5 cover embedding an object-oriented language in Clojure. Because Scala is a hybrid functional–object-oriented language, I didn’t really see the point of doing them in Scala. Therefore the next post will cover chapter 6.

## Types With Units

### The Problem

I have been working on an application that displays various types of data, and some of the data may be displayed in more than one unit of measure, according to the user’s preference. The diversity of units is not just on the output side. The application consumes a number of input formats: an angle value may be in degrees or radians; a distance value may be in meters or feet.

To cope with all these differences, we created an abstraction layer that converts the various incoming data formats into a common format. Only when we need to display a value in a certain unit of measurement do we perform the units conversion to the desired format. There was a number of occurrences of magic numbers to convert values from one unit to another:

```// C#
//Convert from ft/min to m/s
speed = (u.VerticalSpeed * (1 / (3.28084 * 60))) + "  m/s";
```

Obviously, poor practice that I had to clean up.

More frequently there were no magic numbers, but named constants:

```// C#
altitudeValue = Constants.METERS_TO_FEET * u.Position.Altitude;
```

An improvement, for sure, but there’s still a problem. The units are implied here by the calculation, but if I run across `u.Position.Altitude` elsewhere in the program, how do I, as the code maintainer, know that `Altitude` is in meters?

We could depend on convention: Always use SI units. Distances are meters, speeds are meters per second, and so on. Still, from time to time, someone on the team would forget. In fact, the `VerticalSpeed` calculation above is wrong: `VerticalSpeed` is in meters per second, not feet per minute. How can we be sure that no one forgets what the units are?

One convention I employ frequently is to add a suffix to the variable/method that indicates its units:

```// C#
speed = u.VerticalSpeedMeters + " m/s";
```

It works, but can get a little verbose. It becomes necessary to attach a units suffix to every single variable, even when there is no units conversion going on.

Furthermore, every time there is a units conversion, we have to type out the calculation. While simple enough, that’s code duplication. How can we reduce duplication?

I have recently been more scrupulous about encapsulating a frequently performed calculation—even a simple one—within a method named so that it describes the operation. In fact, in doing so, I kill two birds with one stone: reduce code duplication and eliminate the need for a comment because the method name already tells you exactly what it’s doing:

```// C#
lat = ConvertRadiansToDegrees(latitudeRadians);
```

That is better, but it feels a little too C-like. Yeah, it’s a matter of taste, but I don’t like it.

Finally, there’s nothing that prevents me from doing this:

```// C#
lat = ConvertRadiansToDegrees(accelerationMeters);
```

The compiler cannot help me. First, the correct units of acceleration are meters/second², not meters. Second, I am handing an acceleration value to a function that expects an angle value. The compiler does not catch the mismatch because both angles and accelerations are `double`s—as are distances, speeds, flow rates, angular speeds, etc. Can we somehow use the type system to enlist the compiler’s help?

### The Solution

So then, here are the forces our solution has to balance:

• Eliminates magic numbers
• Encapsulates the units conversion algorithm
• Communicates the units of measure when we care, but does not clutter the code when we don’t
• Has a less C-like, more OO feel
• Uses the type system to help prevent accidental mismatches of different measurement types

What if we use custom types for each measurement type rather than a generic `double`? For example, what if we could do this for angles?

```// C#
Angle lat = new Angle(Math.PI / 2.0);
double rad = lat.Radians;
double deg = lat.Degrees;
```

Well, in fact, we can: using classes—or rather C# `struct`s in our case since that is the C# way for value types.

Let’s take the TDD approach and write our test first.

```// C#
namespace UnitsOfMeasureTests.Units
{
[TestFixture]
class AngleTest
{
private const double OneRadianInRadians = 1.0;
private const double OneRadianInDegrees = 180.0 / Math.PI;

private const double OneDegreeInDegrees = 1.0;
private const double OneDegreeInRadians = Math.PI / 180.0;

[Test]
public void TestRadiansProperty()
{
Angle angle;

angle = new Angle(OneRadianInRadians);
Assert.That(angle.Radians, Is.EqualTo(OneRadianInRadians));
angle = new Angle(OneDegreeInRadians);
Assert.That(angle.Radians, Is.EqualTo(OneDegreeInRadians));
}

[Test]
public void TestDegreesProperty()
{
Angle angle;

angle = new Angle(OneRadianInRadians);
Assert.That(angle.Degrees, Is.EqualTo(OneRadianInDegrees));
angle = new Angle(OneDegreeInRadians);
Assert.That(angle.Degrees, Is.EqualTo(OneDegreeInDegrees));
}
}
}
```

Now the implementation:

```//C#
namespace UnitsOfMeasure.Units
{
public struct Angle
{
public readonly double Radians;
public readonly double Degrees;

private const double DegreesPerRadian = 180.0 / Math.PI;

public Angle(double radians)
{
this.Radians = radians;
this.Degrees = radians * DegreesPerRadian;
}
}
}
```

That’s not bad, but we can do better. Consider this:

```// C#
Angle latitude = new Angle(latValue);
```

How do I know at a quick glance whether `latValue` is in radians or degrees? I have no idea unless I look at the constructor to find out what units it expects. To make the the code communicate a little better, let’s employ the named constructor idiom. First, we change our test:

```// C#
namespace UnitsOfMeasureTests.Units
{
[TestFixture]
class AngleTest
{
private const double OneRadianInRadians = 1.0;
private const double OneRadianInDegrees = 180.0 / Math.PI;

private const double OneDegreeInDegrees = 1.0;
private const double OneDegreeInRadians = Math.PI / 180.0;

[Test]
public void TestRadiansProperty()
{
Angle angle;

angle = Angle.InRadians(OneRadianInRadians);
Assert.That(angle.Radians, Is.EqualTo(OneRadianInRadians));
angle = Angle.InRadians(OneDegreeInRadians);
Assert.That(angle.Radians, Is.EqualTo(OneDegreeInRadians));

angle = Angle.InDegrees(OneRadianInDegrees);
Assert.That(angle.Radians, Is.EqualTo(OneRadianInRadians));
angle = Angle.InDegrees(OneDegreeInDegrees);
Assert.That(angle.Radians, Is.EqualTo(OneDegreeInRadians));
}

[Test]
public void TestDegreesProperty()
{
Angle angle;

angle = Angle.InRadians(OneRadianInRadians);
Assert.That(angle.Degrees, Is.EqualTo(OneRadianInDegrees));
angle = Angle.InRadians(OneDegreeInRadians);
Assert.That(angle.Degrees, Is.EqualTo(OneDegreeInDegrees));

angle = Angle.InDegrees(OneRadianInDegrees);
Assert.That(angle.Degrees, Is.EqualTo(OneRadianInDegrees));
angle = Angle.InDegrees(OneDegreeInDegrees);
Assert.That(angle.Degrees, Is.EqualTo(OneDegreeInDegrees));
}
}
}
```

Then we change our implementation to match by making the constructor private and adding the two named constructors `InRadians` and InDegrees:

```// C#
namespace UnitsOfMeasure.Units
{
public struct Angle
{
public readonly double Radians;
public readonly double Degrees;

private const double DegreesPerRadian = 180 / Math.PI;

public static Angle InRadians(double radians)
{
return new Angle(radians);
}

public static Angle InDegrees(double degrees)
{
return new Angle(degrees / DegreesPerRadian);
}

private Angle(double radians)
{
Radians = radians;
Degrees = radians * DegreesPerRadian;
}
}
}
```

Now it is perfectly clear whether we are initializing a new `Angle` object with a radian value or a degree value.

So there it is. We now have an `Angle` value type that eliminates magic numbers and code duplication by encapsulating the units conversions within the `struct`. Instead of being constrained to a primitive `double` value that could be confused with any other `double`, we can now lean on the compiler for help. Finally, instead of having to append units suffixes all over the place, we pass around an object that can give us its value in whatever units we desire only when the units matter:

```// C#
Angle latitude = Angle.InRadians(message.CurrentPosition.Latitude);
latTextBox.Value = String.Format("{0:0}°", latitude.Degrees);
```

### Case In Point: NASA World Wind

I had already dreamt up my design independently, but I came to find out that NASA’s World Wind has an `Angle` class that does things similar to how our `Angle` struct above does. In fact, it has some additional features, such as arithmetic and trigonometric functions, which I should like to add to my `Angle` type in future posts.

## Covariant, Contravariant, Contrabass, Codependent

I can never remember Scala‘s notation to indicate a covariant type vs. a contravariant type, so here it is:

### Covariant `[+A]`

`List` can contain an object of type `A` or any subtype of `A`:

``class List[+A]``

### Contravariant `[-A]`

`Function1` accepts as an input an object of type `T1` or any supertype of `T1` (its return type `R`, however, is covariant):

``trait Function1[-T1, +R]``

### Upper Type Bound `[T <: A]`

The following `findSimilar` function (borrowed from this example) accepts an instance of and a `List` of `Similar` objects or of objects that are subtypes of `Similar`:

`def findSimilar[T <: Similar](e: T, xs: List[T]): Boolean`

### Lower Type Bound `[T >: A]`

`Option#orElse` accepts (and returns) an `Option` containing an object of type `A` or any supertype of `A`:

``final def orElse[B >: A](alternative: ⇒ Option[B]): Option[B]``

## Enumerate, Iterate, Pretty Kate, …

Ever wanted to iterate over some objects using Java’s for each syntax, but the only interface exposed is an Enumeration? I have. And there’s already a way available out of the box.

Ever wanted to iterate over some objects using Java’s `for each` syntax, but the only interface exposed is an Enumeration? I have.

There’s an exercise in the Head First Design Patterns book that adapts an `Enumeration` to the `Iterable` interface. Pretty nifty, so I coded it up and used it in some code at work. Works great!

But then I found this: the `list()` method of the `Collections` class. It stuffs all the items in an `Enumeration` into a `List`. And it’s been there since Java 1.4! Where in the world have I been?

Anyway, the upshot is that instead of having to use this old drivel

``````Enumeration<Nargle> nargles = Nargle.getNargles();
while (nargles.hasMoreElements()) {
Nargle nargle = nargles.nextElement();
// do something with nargle
}``````

You can do this

``````for (Nargle nargle : Collections.list(Nargle.getNargles())) {
// do something with nargle
}``````

Yes, that is a sight better.

## Webkit Disrespects My Personal Whitespace

I’ve been trying to put some of CSS3’s `nth-*` selectors to use in a site I’m working on right now, and I’ve run into a problem. I’m testing my markup and styles in Safari 5 (before moving on to other browsers), and I am trying to style child elements 3, 7, 11, etc. So I write this rule:

``p:nth-of-type(4n - 1) { … }``

That should work, right? After all, 4(1) − 1 = 3; 4(2) − 1 = 7; 4(3) − 1 = 11.

Well I open up Safari, and my changes haven’t taken. OK. How about a different but equivalent equation?

``p:nth-of-type(4n + 3) { … }``

Again, pretty simple: 4(0) + 3 = 3; 4(1) + 3 = 7; 4(2) + 3 = 11. The last one hasn’t taken, for whatever reason, but this one’s right on.

Still nothing.

I begin to doubt my math skills. I’ve been doing software of one type or another for 15 years, but my bachelor’s degree is in electrical engineering. I had to take four calculus classes, linear algebra, and differential equations. OK, I haven’t used most of that in years, but `an + b` is simple algebra—stuff I’ve been doing for over 20 years. I know simple algebra.

I decide to fire up Firefox (version 3.6.12). Lo and behold, there is the formatting I’ve been trying desperately to get to show up. Firefox gets it (so does Opera, for the record), but Safari doesn’t (neither does Chrome). Evidently we have a Webkit bug.

For grins, even though it won’t get me where I want to go, I try this:

``p:nth-of-type(4n) { … }``

The formatting appears correctly in both Firefox and Safari! Therefore Webkit does understand `nth-of-type`, but something about `an + b` gives it heartburn that `an` doesn’t.

I try one more thing: remove the whitespace in the equation.

``p:nth-of-type(4n+3) { … }``

It works! Safari and Firefox both rendered the formatting properly. Webkit just doesn’t care for the whitespace.

But is whitespace forbidden in the equation? Here’s what the spec has to say:

Whitespace is permitted after the “(“, before the “)”, and on either side of the “+” or “-” that separates the an and b parts when both are present.

Valid Examples with white space:

``````:nth-child( 3n + 1 )
:nth-child( +3n - 2 )
:nth-child( -n+ 6)
:nth-child( +6 )``````

So then, we do have a bug. Webkit doesn’t respect the whitespace in `nth-child` and the other `nth-*` selectors. The workaround is easy enough, but it’s going to be hard for me to break the habit of adding space around the arithmetic operator. It’s a best practice, so far as I’m concerned, for code readability. Nevertheless, the expressions are simple enough that it’s not a terrible price to pay to get Safari/Chrome to play.

If you want to see it in action, check out this test file. Below is a screen capture of Safari’s rendering (left) and Firefox’s rendering (right). As you can see, Safari only renders `nth-child(2n+1)` correctly while Firefox renders them both correctly. nth-child Rendering Comparison (Safari vs. Firefox)

## African Or European Swallows?

I’m thinking they must be African swallows. The Notorious Twitter Fail Whale

## Fortran Programming II

Programming in Fortran is like being human: You can do it right, but most of the time you don’t.

## Sugar Scrub

I am reading Andy Clarke’s Transcending CSS, and in it he encourages looking for Web design inspiration in places other than the Web: cereal boxes, newspapers, magazines, buildings, to name a few. (This is something I’ve done for some time now, but I’ve been making a more conscious effort of late, given his advice.)

This morning I picked up a tube of my wife’s facial scrub. I looked for anything interesting in the design on the front. Then I looked at the back, which contains, among other things, an ingredient list. I wasn’t scanning the ingredient list as much as my eyes just happened to fall on one word:

Saliva.

Saliva! They put saliva in facial scrub? I looked again.

Salvia.

Salvia officinalis (sage) leaf extract. Ah, helps to keep reading past the line break.