First Steps into Scala - scala

Question

I m trying to learn scala these days.
I get confused with _ operator.
How can I use it in the following program ?
Also how this program can be made more concise ?
I have learnt that scala promotes the use of val over var, in this case how can we use val for balance ?
private object Main {
def main(args: Array[String]): Unit = {
val acc1 = new PiggyBank(5)
acc1.printBalance
acc1 deposit 5
acc1.printBalance
acc1 withdraw 5
acc1.printBalance
}
}
private class PiggyBank(open_Bal: Int) {
var balance = open_Bal
def deposit(value: Int) = balance = balance + value
def printBalance = println(balance)
def iswithdrawable(value: Int) = balance >= value
def withdraw(value: Int) = {
if (iswithdrawable(value)) {
balance = balance - value
}
}
}
Thanks in Advance :)

Answer 1

You're probably going to get a million answers here :) But, based on the content of your question, you need to read a book. I'd recommend Programming in Scala 2nd Edition. I've read it twice and it's gotten dog-eared and coffee stained in the process.
The reason I say this is because Scala presents you with a new paradigm, and you're writing Java code in Scala. This is perfectly fine for starters but you're not going to learn what you want to learn that way. The book is a great start that will give you the foundation to learn more.
For example, here's what I'd change in your code:
case class PiggyBank(balance: Double) {
def deposit(amount: Double) = PiggyBank(balance + amount)
def withdraw(amount: Double): Option[PiggyBank] = {
if (balance >= amount) Some(PiggyBank(balance - amount))
else None
}
override def toString() = balance.toString
}
But "why" I would want to do it that way is the real question, and it's that question that you really need to have answered, I argue. In a nutshell, it's immutable and a bit more functional (although, this is a toy example and there's tons of room for improvement here), but why is it and why do we care? Books answer this stuff.
Given that, you can start to use the _ a bit if you want. For example:
val result = PiggyBank(500) withdraw 200 flatMap { _.withdraw(200) }
println(result.getOrElse(0))
But if you're like most noobs (like me a long while ago), you're going to ask "Why on earth is that better??". That's not an answer you're going to find in a quick SO post. I could go on and on and on and on but the bottom line is that there are books out there that have already done that, and have done that better than I can.

Answer 2

There is no need for _ here. _ is not an operator, but a placeholder for parameters in closures. E.g. when you call a foldLeft an a collection of integers to you sum them up you could write List(1,2,3,4).foldLeft(0)(_ + _) instead of List(1,2,3,4).foldLeft(0)((x,y) => x + y). The first _ will be the x in the second example and the second _ the y.

Answer 3

You would use val with immutable objects. Since your PiggyBank is mutable, you need var for the mutable internal state.
You could turn your PiggyBank in immutable this way (basically creating a new immutable object each operation that would change the state of the object):
class PiggyBank(val balance : Int) {
def deposit(value: Int) = new PiggyBank(balance + value)
def printBalance = println(balance)
def iswithdrawable(value: Int) = balance >= value
def withdraw(value: Int) = if (iswithdrawable(value)) new PiggyBank(balance - value) else this;
}
So you could write this:
object Main {
def main(args: Array[String]): Unit = {
val acc1 = new PiggyBank(5) deposit 5 withdraw 5
acc1.printBalance
}

Answer 4

Regarding underscore/wildcards, these are helpful reads, "_" is frequently encountered in idiomatic code:
http://www.slideshare.net/normation/scala-dreaded
http://agileskills2.org/blog/2011/05/01/revealing-the-scala-magicians-code-expression/
Book index for Staircase vers. 2 has 7 entries for "_":
"curried functions", "existential types", "function literals",
"in identifiers" "import statements" "match expressions" and "initialize field to default value"
http://www.artima.com/pins1ed/book-index.html#indexanchor
very telling comment: underscore as a wildcard at both the term and type level plus as a way to coerce a method into a first class function.
http://lambda-the-ultimate.org/node/2808#comment-41717