Help wanted with port of F# code to Scala.

Ok, thinking about this, I don't really want to have X covariant in
Unbounded[X] - I just want to be able to write NegativeInfinity
without a type parameter when I use it, e.g. Finite(45) >
NegativeInfinity for a rather contrived example. (I use
NegativeInfinity as a special guaranteed lower bound when checking
through a sequence of X's - saves me from writing a type class
implementation providing a minimum over all values for each X, in case
anyone is wondering what this is for. In practice the X can be a
structured type where it can get fiddly defining a lower bound, so it
easier to just lift the type X rather than work directly within it.)

So I tried tidying things up based on where I got last time and have
golfed it to:-

import scala.math.Ordered

import org.scalatest.Suite

class Unbounded[X <% Ordered[X]] extends Ordered[Unbounded[X]] {
def compare(another: Unbounded[X]) = (this, another) match {
case (Finite(thisUnlifted), Finite(anotherUnlifted)) =>
thisUnlifted compare anotherUnlifted
case (Foo(), Foo()) => 0
case (Foo(), _) => -1
case (_, Foo()) => 1
}
}

case class Finite[X <% Ordered[X]](unlifted: X) extends Unbounded[X]

case class Foo[X <% Ordered[X]]() extends Unbounded[X] {
implicit def fakeCovarianceHack[Y <% Ordered[Y]](ni: this.type) =
Foo[Y]()
}

object NegativeInfinity extends Foo[Nothing] {
}

class TestSuite extends Suite {

def testOperations() = {
val negativeInfinity = NegativeInfinity

val twentyThree = Finite(23)

assert(negativeInfinity < twentyThree)

val fortyFive = Finite(45)

assert(twentyThree < fortyFive)

assert(!(twentyThree > fortyFive))

assert(Finite(23) == twentyThree)

assert(negativeInfinity < fortyFive)

//assert(negativeInfinity < Finite(45)) // COMPILE ERROR WHEN
UNCOMMENTED: Huh?

assert(NegativeInfinity < fortyFive)

//assert(NegativeInfinity < Finite(45)) // COMPILE ERROR WHEN
UNCOMMENTED: Huh?

assert(Finite(45) > NegativeInfinity)

assert(NegativeInfinity == NegativeInfinity)

assert(!(Foo[Int]() > Foo()))
assert(!(NegativeInfinity > Foo[Nothing]()))
assert(NegativeInfinity <= Foo[Nothing])
assert(Foo[Nothing] <= negativeInfinity)
assert(negativeInfinity <= Foo[Nothing])
assert(NegativeInfinity <= NegativeInfinity)
assert(!(NegativeInfinity > NegativeInfinity))

assert(NegativeInfinity < twentyThree)
}
}

object Main extends App {
(new TestSuite).execute()
}

For the sake of exposition in this post, I've changed the name of the
case class from NegativeInfinity to Foo to distinguish it from the
NegativeInfinity object I would actually use in client code.

This works, but now I've traded the compile problem in the original
piece of code for a new one - there seems to be some subtle difference
between a named value of type Finite[Int] and an expression of the
same type that prevents the commented out lines from type checking
when uncommented.

Could anybody shed some light on this, please?

Cheers,

Gerard

Hi,

I thought I'd repost this as I'm reasonably happy with the solution I
ended up with, except for one final detail - I see an odd compile
error when I comment out either of the two commented lines in the code
below.

It's got me completely foxed. :-(

(Look in the test at the end for 'COMPILE ERROR' in comments).

What seems odd is that there are several variations on the commented
line which all compile fine and do the right thing at runtime.

Can anybody explain whether this is a bug or some obscure corner case
in Scala's type inference?

I'm using Scala 2.9 as per an Eclipse plugin update from this week.

(BTW: if there is a more appropriate forum for these sorts of
questions, please let me know.)

Cheers,

Gerard

import scala.math.Ordered

import org.scalatest.Suite

abstract class Unbounded[X <% Ordered[X]] extends
Ordered[Unbounded[X]] {
def compare(another: Unbounded[X]) = (this, another) match {
case (Finite(thisUnlifted), Finite(anotherUnlifted)) =>
thisUnlifted compare anotherUnlifted
case (Foo(), Foo()) => 0
case (Foo(), _) => -1
case (_, Foo()) => 1
}
}

case class Finite[X <% Ordered[X]](unlifted: X) extends Unbounded[X] {
}

case class Foo[X <% Ordered[X]]() extends Unbounded[X] {
implicit def fakeCovarianceHack[Y <% Ordered[Y]](ni: this.type) =
Foo[Y]()
}

object NegativeInfinity extends Foo[Nothing] {
}

class TestSuite extends Suite {

def testOperations() = {
val negativeInfinity = NegativeInfinity

val fortyFive = Finite(45)

assert(negativeInfinity < fortyFive)

//assert(negativeInfinity < Finite(45)) // ****** COMPILE ERROR
WHEN UNCOMMENTED: Huh? ******

assert(NegativeInfinity < fortyFive)

//assert(NegativeInfinity < Finite(45)) // ****** COMPILE ERROR
WHEN UNCOMMENTED: Huh? ******

assert(Finite(45) > negativeInfinity)

assert(Finite(45) > NegativeInfinity)

def wrap(x:Int) = Finite(x)

assert(NegativeInfinity < wrap(45))

assert(wrap(45) > NegativeInfinity)

assert(NegativeInfinity < (Finite(45): Unbounded[Int]))

assert(NegativeInfinity < (Finite(45): Finite[Int]))

//********************************************

val twentyThree = Finite(23)

assert(negativeInfinity < twentyThree)

assert(twentyThree < fortyFive)

assert(!(twentyThree > fortyFive))

assert(Finite(23) == twentyThree)

//********************************************

assert(NegativeInfinity == NegativeInfinity)

assert(!(Foo[Int]() > Foo()))
assert(!(NegativeInfinity > Foo[Nothing]()))
assert(NegativeInfinity <= Foo[Nothing])
assert(Foo[Nothing] <= negativeInfinity)
assert(negativeInfinity <= Foo[Nothing])
assert(NegativeInfinity <= NegativeInfinity)
assert(!(NegativeInfinity > NegativeInfinity))

assert(NegativeInfinity < twentyThree)
}
}

object Main extends App {
(new TestSuite).execute()
}

Hi Gerard,

this looks certainly interesting!

I guess if you use negativeInfinity (which extends Foo[Nothing] -> Unbounded[Nothing]) on the left the argument type of the Ordered methods (<, >, ...) is already fixed to Nothing and if negativeInfinity is on the right it works because of Covariance ...

Just my guess ...

Bye,


Simon