map should (contain key ("one") and not contain value (10))
result should be => (0)
book should have (title ("Programming in Scala"))
tempFile should not be a ('directory)
quotient should be (1.0 plusOrMinus 0.2)

Als kleine Demonstration zeige ich hier nun wie man das ‘using’ Konstrukt aus C# in Scala nachahmen kann. Die Funktionsweise dieses Blocks ist simpel, aber immer wieder nützlich. Man übergibt einen Stream bzw. irgendeine Instanz, die IDisposable implementiert, verwendet diese und das Schließen bzw. Zerstören der Instanz geschieht ganz von alleine.

using (var file = File.CreateText("test.dat")
{
    file.WriteLine("C# is");
    file.WriteLine("great");
}

Was wirklich passiert ist, dass der Compiler ein try finally Block erzeugt, der in jedem Fall .Dispose() aufruft, womit dann im Falle eines Streams auch automatisch .Close() zum Zuge kommt. Fangen wir mit der Scala-Übersetzung an. Eine erste Methode könnte eine simple Funktion höherer Ordnung in der folgenden Art sein:

val file = new PrintWriter("test.dat")
using (file, () => {
  file.println("scala is")
  file.append("great")
})

def using(stream: Closeable, operation: () => Unit) {
  try {
    operation
  } finally {
    stream.close()
  }
}

Using erwartet den Stream sowie die auszuführende Funktion, die nichts erwartet und nichts zurückgibt (Unit entspricht praktisch void in C#). Wir können die Syntax noch weiter verbessern, indem wir den zweiten Parameter in einen By-Name-Parameter umschreiben:

def using(stream: Closeable, operation => Unit)

Nun fehlen die zwei Klammern in der Signatur, was dazu führt, dass wir sie auch beim Aufrufen weglassen können:

using (file, { ... })

Das kommt der Version aus C# schon recht nahe. Einen Unterschied können wir jedoch nicht verstecken – in Scala sind Variablendeklarationen keine Ausdrücke. Somit können wir sie z.B. nicht wie in C an eine Methode übergeben, sondern müssen die Variable im Voraus definieren und sie dann an using übergeben.
Doch trotzdem gibt es hier noch Verbesserungsmöglichkeiten. Wir können using in eine partiell auswertbare Methode umwandeln, sodass using einen Parameter erwartet und als Ergebnis wieder eine Funktion zurück liefert, die nur noch die Operation als Argument bekommt. Das sieht dann so aus:

def using(stream: Closeable)(operation: => Unit)  { ... }

Damit sind wir nunam Ziel angelangt. Wir können das using-Konstrukt fast wie in C# nutzen (in Scala können normale Klammern auch durch geschweifte ersetzt werden):

val file = new PrintWriter("test.dat")

using (file) {
  file.println("scala is")
  file.append("great")
}

Übrigens wird Scala nach Java Bytecode kompiliert und ist somit praktisch kompatibel und gemeinsam einsetzbar mit allen bestehenden Java-Systemen. Ein Compiler für die Common Language Runtime ist auch in der Entwicklung, der Support für Java ist aber wesentlich besser.

Beim Lesen des Buchs “Programming in Scala” (welches übrigens ausgezeichnet geschrieben ist) sind mir erstmals die Unterschiede zwischen den Programmierparadigmen wirklich klar geworden. Umso interessanter ist es dann nach und nach zu sehen wie Scala beides fusioniert und dabei etwas neues schafft. Das erstaunlichste an Scala ist aber wie man selber zu einem Sprach-Kreatonist werden kann! Die Programmiersprache ist in ihrem Kern recht einfach, aber dennoch so flexibel, dass jeder die Sprache erweitern kann, um sie an die entsprechenden Bedürfnisse anzupassen.

Das beste Beispiel ist die Actors-Bibliothek zur Abstraktion der parallelen Ausführung von Programmcode. Eine Idee – ursprünglich aus der Sprache Erlang – die es mittlerweile fast in jede Sprache geschafft hat als ein normales Framework. Scala geht weiter und integriert nicht nur Funktionalität, sondern auch Syntax aus Erlang und schafft somit eine ganz natürliche Integration – so als wäre das Programmieren mit Actors schon immer Bestandteil der Sprache.

Ein paar schöne Code-Beispiele zu Actors-Bibliothek befinden sich direkt hier.

Im nächsten Beitrag werde ich demonstrieren wie man das nützliche in C# bekannte using-Konstrukt nachbaut, um Streams etc. automatisch zu schließen.