Question

I have the following code, but I can’t get it to work. As soon as I place a while loop inside the case, it’s returning a unit, no matter what I change within the brackets.

case While(c, body) =>
    while (true) {
      eval(Num(1))
    }
}

How can I make this while loop return a non-Unit type?

I tried adding brackets around my while condition, but still it doesn’t do what it’s supposed to.

Any pointers?

Update

A little more background information since I didn’t really explain what the code should do, which seems to be handy if I want to receive some help;

I have defined a eval(exp : Exp). This will evaluate a function.
Exp is an abstract class. Extended by several classes like Plus, Minus (few more basic operations) and a IfThenElse(cond : Exp, then : Exp, else : Exp). Last but not least, there’s the While(cond: Exp, body: Exp).

Example of how it should be used;

eval(Plus(Num(1),Num(4)) would result in NumValue(5). (Evaluation of Num(v : Value) results in NumValue(v). NumValue extends Value, which is another abstract class).

eval(While(Lt(Num(1),Var("n")), Plus(Num(1), Var("n"))))

Lt(a : Exp, b : Exp) returns NumValue(1) if a < b.

Answer 1

It’s probably clear from the other answer that Scala while loops always return Unit. What’s nice about Scala is that if it doesn’t do what you want, you can always extend it.

Here is the definition of a while-like construct that returns the result of the last iteration (it will throw an exception if the loop is never entered):

def whiley[T](cond : =>Boolean)(body : =>T) : T = {
  @scala.annotation.tailrec
  def loop(previous : T) : T = if(cond) loop(body) else previous
  if(cond) loop(body) else throw new Exception("Loop must be entered at least once.")
}

…and you can then use it as a while. (In fact, the @tailrec annotation will make it compile into the exact same thing as a while loop.)

var x = 10
val atExit = whiley(x > 0) {
  val squared = x * x
  println(x)
  x -= 1
  squared
}
println("The last time x was printed, its square was : " + atExit)

(Note that I’m not claiming the construct is useful.)