Making a while-loop more scala-esqe - scala

Question

It is quite clear what the loop below accomplishes. I somewhat think that it could be made more scala-esque, but I can't quite see it. I'm posting this to see if anyone has more inspiration than me.
var bunnies: List[Bunny] = List.fill(nBunniesAtStart)(generateInitialBunny)
var doContinue = true
while (doContinue) {
val prevBunnies = bunnies
bunnies = evolveOneYear(bunnies)
print(bunnies, prevBunnies)
if (bunnies.isEmpty) {
println("\n\n\n No more bunnies...")
doContinue = false
} else {
println("Hit Enter to continue, or q + Enter to quit.\n")
doContinue = readLine.isEmpty()
}
}
I wrote this code as an answer to a codereview post.
EDIT:
thanks to #wingedsubmariner and #Kigyo, I have this alternative:
val startBunnies: List[Bunny] = List.fill(nBunniesAtStart)(generateInitialBunny)
userInputLoop(startBunnies, "")
#tailrec
def userInputLoop(bunnies: List[Bunny], userInput: String): Unit = {
if (userInput.nonEmpty) println("Exiting")
else evolveOneYear(bunnies) match {
case Nil =>
print(Nil, bunnies)
println("No more bunnies...")
case newBunnies =>
print(newBunnies, bunnies)
userInputLoop(newBunnies, readLine())
}
}
Or
val startBunnies: List[Bunny] = List.fill(nBunniesAtStart)(generateInitialBunny)
userInputLoop(startBunnies)
#tailrec
def userInputLoop(prevBunnies: List[Bunny]): Unit = {
evolveOneYear(prevBunnies) match {
case Nil =>
print(Nil, prevBunnies)
println("No more bunnies...")
case bunnies =>
print(bunnies, prevBunnies)
if (readLine().nonEmpty) println("Exiting.")
else userInputLoop(bunnies)
}
}
EDIT 2:
Another attempt, build from some ideas of Chris Martin and Ben Kovitz:
class NoMoreBunniesException extends Exception("No more bunnies...")
class UserStoppageException extends Exception("Exiting at your request.")
def doesUserWantToContinue(): Try[_] = {
println("Hit Enter to continue, or q + Enter to quit.\n");
if (readLine().isEmpty) Success() else Failure(new UserStoppageException)
}
def validateBunnies(bunnies: List[Bunny]): Try[_] = {
if (bunnies.isEmpty) Failure(new NoMoreBunniesException)
else Success()
}
def checkNotEmptyAndUserContinuation(bunnies: List[Bunny]): Try[_] =
validateBunnies(bunnies).flatMap(_ => doesUserWantToContinue)
val firstBunnies = List.fill(nBunniesAtStart)(generateInitialBunny)
println(s"${buildBunniesReport(firstBunnies).toString}\n\n")
val timeline = Stream.iterate(firstBunnies)(evolveOneYear)
val timelineWithPrev = timeline.tail.zip(timeline)
val statusAndReportTimeline = timelineWithPrev.map {
case (bunnies, prevBunnies) =>
(checkNotEmptyAndUserContinuation(bunnies), buildFullReport(bunnies, prevBunnies))
}
// main loop including user interaction
statusAndReportTimeline.takeWhile {
case (Success(_), _) => true
case (Failure(e), report) => { println(s"${report}\n\n${e.getMessage}"); false }
}.foreach { case (_, report) => println(report) }

Answer 1

Here's a solution that's more functional (perhaps also more abstruse):
val firstBunnies = List.fill(nBunniesAtStart)(generateInitialBunny)
val timeline = Stream.iterate(firstBunnies)(evolveOneYear)
val inputLines = Source.fromInputStream(System.in).getLines()
timeline.zip(timeline.tail).iterator
.takeWhile({ case (previousBunnies, bunnies) => previousBunnies.nonEmpty })
.zip(Iterator.single("") ++ inputLines)
.takeWhile({ case (_, input) => input.isEmpty })
.map({ case ((previousBunnies, bunnies), _) =>
(bunnies, previousBunnies) + (
if (bunnies.isEmpty) "No more bunnies..."
else "Hit Enter to continue, or q + Enter to quit."
)
})
.foreach(println)

Answer 2

You can make it more idiomatic scala by using a tail-recursive function instead of a while loop and eliminiating the vars:
import scala.annotation.tailrec
val startBunnies = List.fill(nBunniesAtStart)(generateInitialBunny)
#tailrec
def loop(prevBunnies: List[Bunny]): Unit = {
val bunnies = evolveOneYear(prevBunnies)
print(bunnies, prevBunnies)
if (bunnies.isEmpty) {
println("\n\n\n No more bunnies...")
} else {
println("Hit Enter to continue, or q + Enter to quit.\n")
if (readLine.isEmpty)
loop(bunnies)
}
}
loop(startBunnies)

Answer 3

// Separate the functional logic ...
val firstBunnies = List.fill(nBunniesAtStart)(generateInitialBunny)
val timeline = Stream.iterate(firstBunnies)(evolveOneYear)
for ((previousBunnies, bunnies) <- timeline zip timeline.tail) {
// ... from the I/O.
print(bunnies, previousBunnies)
if (bunnies.isEmpty) {
println("No more bunnies...")
return
} else {
println("Hit Enter to continue, or q + Enter to quit.")
}
if (readLine().nonEmpty) return
}

Answer 4

Here's yet another way to do it, aiming for clarity and simplicity.
import util.control.Breaks._
val bunniesStream: Stream[List[String]] = firstBunnies #:: bunniesStream.map(evolveOneYear)
breakable {
for (bunnies <- bunniesStream) {
println(bunnies)
if (bunnies.isEmpty) {
println("No more bunnies...");
break
} else {
println("Hit Enter to continue, or q + Enter to quit.\n");
if (!readLine().isEmpty) break
}
}
}
The use of breakable suggests that this is not idiomatic Scala code.

Answer 5

The more I consider this, the more I'm bothered by the idea of blocking on the InputStream over a human timescale. So here's an approach using Akka!
The setup:
import akka.actor.{Actor, ActorRef, ActorSystem, Props}
// The actor system
val system = ActorSystem()
// The actors: a bunny farm, and a console to interact with it
val farm = system.actorOf(Props[BunnyFarm])
system.actorOf(Props(classOf[BunnyConsole], farm))
// Keep alive until the actor system terminates
system.awaitTermination()
The bunny farm:
object BunnyFarm {
// Define the messages that a bunny farm uses
case object Advance
case class Result(bunnies: Seq[Bunny], previousBunnies: Seq[Bunny])
}
class BunnyFarm extends Actor {
import BunnyFarm._
// A bunny farm's state consists of a list of its bunnies
var bunnies = List.fill(nBunniesAtStart)(generateInitialBunny)
def receive = {
case Advance =>
// Advance the state of the farm one year
val previousBunnies = bunnies
bunnies = evolveOneYear(bunnies)
// Reply to the sender with the result
sender ! Result(bunnies = bunnies, previousBunnies = previousBunnies)
}
}
The console interface:
class BunnyConsole(farm: ActorRef) extends Actor with akka.camel.Consumer {
// Read from stdin
def endpointUri = "stream:in"
// Initially advance the farm once
farm ! BunnyFarm.Advance
def receive = {
case m: akka.camel.CamelMessage => self forward m.bodyAs[String]
// Each string message represents a line of user input
case s: String => s match {
case "" => farm ! BunnyFarm.Advance
case _ => quit()
}
// When the bunny farm sends a result...
case r: BunnyFarm.Result =>
println(s"Previous bunnies: ${r.previousBunnies}")
println(s"New bunnies: ${r.bunnies}")
if (r.bunnies.nonEmpty) {
println("Hit Enter to continue, or q + Enter to quit.")
} else {
println("No more bunnies...")
quit()
}
}
// Terminate the actor system, thus halting the program
def quit() = context.system.shutdown()
}
Dependencies:
com.typesafe.akka:akka-actor
com.typesafe.akka:akka-camel
org.apache.camel:camel-stream
Edit - The same solution refactored for brevity.
Setup:
import akka.actor.{Actor, ActorSystem, Props}
val system = ActorSystem()
system.actorOf(Props(classOf[BunnyConsole]))
system.awaitTermination()
Console:
class BunnyConsole extends Actor with akka.camel.Consumer {
def endpointUri = "stream:in"
var bunnies = List.fill(nBunniesAtStart)(generateInitialBunny)
advance()
def receive = {
case m: akka.camel.CamelMessage => m.bodyAs[String] match {
case "" => advance()
case _ => quit()
}
}
def advance() {
val previousBunnies = bunnies
bunnies = evolveOneYear(bunnies)
print(bunnies, previousBunnies)
if (bunnies.nonEmpty) {
println("Hit Enter to continue, or q + Enter to quit.")
} else {
println("No more bunnies...")
quit()
}
}
def quit() = context.system.shutdown()
}

Answer 6

Here's yet another approach. It's horrible. I post it here in the hope that it will inspire someone to re-do its essential idea in a more readable or at least conventional way.
val bunniesStream = Stream.iterate(firstBunnies)(evolveOneYear)
case class Interaction(bunnies: List[String]) {
lazy val print: Unit = println(bunnies)
lazy val continue: Boolean = {
print
if (bunnies.isEmpty) { println("No more bunnies..."); false }
else userOK
}
lazy val userOK: Boolean = {
println("Hit Enter to continue, or q + Enter to quit.\n");
readLine().isEmpty
}
}
bunniesStream.map(Interaction).takeWhile(_.continue).force
The idea that I'm trying to implement here is to get the user's input by lazy evaluation. What makes it hard to do the loop in a functional style is the fact that you don't know when to stop the loop until after you've read the user's input, but you might need to stop the loop before reading the user's input.
The last line bundles all the input and output into an expression. Without .force, that expression should evaluate to an object which you can then pass to other functions as you like. This seems to follow the spirit of functional programming. No input or output should happen until you do a .force. Except it does, because there's something fundamentally wrong with my approach. I don't quite know what it is. Maybe the error has something to do with my mixing decision-making with input/output in the Interaction class.