Vermischtes


In letzter Zeit ist eine Menge passiert, deshalb hier ein paar Links. Zuerst sei erwähnt, dass Scala 2.9.0 Release Candidate 2 sowie NetBeans 7.0 erschienen sind. Das passende Scala Plugin dafür gibt es auch schon. Für Eclipse gibt es immerhin die zweite Beta-Version des Plugins.

Dann hat die Ankündigung der neuen JVM-Sprache Ceylon von RedHat einige Wellen geschlagen. Ich habe einige Artikel dazu gelesen, aber dieser hier von Lachlan O’Dea trifft meiner Meinung nach den Nagel auf den Kopf.

Zum Schluss noch eine kleine Anekdote am Rande: Ich war schon einigermaßen stolz auf meine Antwort zu dieser Frage auf Stackoverflow, bei der es darum ging, Vergleichsfunktionen einfacher zu implementieren. Ich schlug ein kleines Framewörkchen vor:

abstract sealed class CompResult(val toInt:Int) {
  def andThen(next: => CompResult): CompResult
}
case object LT extends CompResult(-1) {
 def andThen(next: => CompResult) = LT
}
case object EQ extends CompResult(0) {
  def andThen(next: => CompResult) = next
}
case object GT extends CompResult(1) {
  def andThen(next: => CompResult) = GT
}

implicit def int2Comp(n:Int) =
   if (n == 0) EQ else if (n < 0) LT else GT

Damit kann man Vergleichsfunktionen für Ordered[T] oder Ordering[T] so schreiben:

 
case class Person(firstName: String, lastName: String, age: Int)
  extends Ordered[Person] {
  def compare(that: Person): Int = {
    (this.lastName compareTo that.lastName).
    andThen (this.firstName compareTo that.firstName).
    andThen (this.age compare that.age).toInt
  }
}

Aber als ich einen ähnlichen Vorschlag für Java-Code machte…

public enum Compare {
    LT, EQ, GT;

    public int toInt() {
       switch(this) {
           case LT: return -1;
           case EQ: return 0;
           case GT: return 1;
           default: throw new AssertionError();    
       }    
    }

    public Compare cp(int v1, int v2) {
        if(this == EQ) return v1 < v2 ? LT : v1 > v2 ? GT : EQ;
        else return this;
    }

    //... here the cp methods for other primitives 

    public <T extends Comparable<T>> Compare cp(T v1, T v2) {
        if(this == EQ) {
            int result = v1.compareTo(v2);
            return result < 0 ? LT : result > 0 ? GT : EQ;
        } else {
            return this;
        }    
    }
}

//Verwendung

@Override
public int compareTo(Version that) {
   return EQ.cp(this.major, that.major)
            .cp(this.minor, that.minor)
            .cp(this.minor2, that.minor2)
            .toInt();
}

… wurde ich mit einem „gibt’s schon“ abgebürstet. Und tatsächlich ähnelt der Code (bis auf die Verwendung von enums) diesem hier von Apache Commons wie ein Osterei dem anderen. Es gibt halt nichts neues unter der Sonne…

Advertisements

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s