Now I’m continuing to the rest of your Scala posts :)

congratulations for your Scala blogs. I found this one using Google. It forwarded me to your foldLeft explanation. That one forwarded me to your Tail-Recursion basics. While reading them, Google forwarded me to your “Null, null, Nil, …” blog.

These blogs are very good, because they are natural and easy to understand! The main problem of Scala is the lack of good, easy to ready blogs and books, still. Odersky and some others wrote books with good contents, but these books are only good as reference book, because they are to difficult to understand IMO.

Best regards,
Kai Wähner (Twitter: @KaiWaehner)

Go for Scala & functional programming!

class Vector2D(val x: Double, val y: Double) {
def +(that: Vector2D) = new Vector2D(this.x + that.x, this.y + that.y)
}

Now, if you have several vectors that you want to sum, you do it just as for integers.

val finalVector = vectorList.foldLeft(new Vector(0,0))(_+_)

Or say you had a list of employees and you want to calculate the yearly payroll:

val payroll = employeeList.foldLeft(0)(_+_.salary)

Or perhaps a user has selected a number of Products and he is ready to purchase:

val purchaseOrder = productList.foldLeft(new PurchaseOrder)(_.addProduct(_))

Is this the kind of thing you were looking for?

thanks for the articles. I really enjoyed reading ‘em all.
Here are some examples on learning scala with your posts (MyList extension):

def foldLeft[B](z: B)(f: (B, A) => B): B = {
def loop(l:MyList[A], acc: B, ff: (B, A) => B):B = {
if (!l.isEmpty) loop(l.tail, ff(acc, l.head), ff)
else acc
}

loop(this, z, f)
}

def foldRight[B](z: B)(f: (A, B) => B): B =
this.reverse.foldLeft(z)((res,cur) => f(cur, res))

def foreach(f: A => Unit) {
this.foldLeft()((res, cur) => f(cur))
}

def forall(f: A => Boolean): Boolean =
this.foldLeft[Boolean](true)((res, cur) => res && f(cur))

def length() : Int =
this.foldLeft(0)((sum,_) => sum + 1)

def map[B](f: A => B): MyList[B] =
this.foldRight[MyList[B]](MyList[B]())((cur, res) => f(cur) :: res)
//this.foldLeft[MyList[B]](MyList[B]())((res, cur) => f(cur) :: res).reverse

def filter(f: A => Boolean): MyList[A] =
this.foldLeft[MyList[A]](MyList())((res, cur) => if (f(cur)) {cur :: res} else res).reverse

def reduceLeft[B >: A](f: (B, A) => B): B =
if (isEmpty) throw new UnsupportedOperationException(“empty.reduceLeft”)
else tail.foldLeft[B](head)(f)

def reduceRight[B >: A](f: (A, B) => B): B =
if (isEmpty) throw new UnsupportedOperationException(“empty.reduceLeft”)
else tail.foldRight[B](head)(f)

def exists(p: A => Boolean): Boolean =
this.foldLeft[Boolean](false)((res, cur) => res || p(cur))

// no foldLeft but functional and tail-recursive
def indices: MyList[Int] = {
def loop(l: MyList[A], res: MyList[Int], idx:Int):MyList[Int] =
if(! l.isEmpty) loop(l.tail, idx :: res, idx+1)
else res

loop(this, MyList[Int](), 0).reverse
}

def dropWhile(p: A => Boolean): MyList[A] = {
def loop (l:MyList[A], f: A => Boolean): MyList[A] =
if (!l.isEmpty && f(l.head)) loop (l.tail, f)
else l

loop(this, p)
}

def takeWhile(p: A => Boolean): MyList[A] = {
def loop(l: MyList[A], res: MyList[A], f: A => Boolean): MyList[A] =
if (!l.isEmpty && f(l.head)) loop(l.tail, l.head :: res, f)
else res

loop(this, MyList[A](), p) reverse
}

def drop(n: Int): MyList[A] = {
def loop(l: MyList[A], idx:Int, cur: Int):MyList[A] =
if (!l.isEmpty && cur 0) loop(l.tail, idx, cur+1)
else l

loop(this, n, 0)
}

def reverseMap[B](f: A => B): MyList[B] = {
def loop(l: MyList[A], res: MyList[B]): MyList[B] = {
if(l.isEmpty) res
else loop(l.tail, f(l.head) :: res)
}
loop(this, MyList())
}

Sorry if the formatting is broken :)