A quick sample of Lists and Tuples in Scala

So I've been challenged with a simple problem to solve in Scala, that is; to take a List of values and and then sum each corresponding value in the list together into a resultant list.

For example:

[1,2,3,4,5] becomes [3,5,7,9]

You can accomplish this in Scala using the List class and its functions, these include:

• zip : this function takes an input list and creates a list of tuples with each mapping pair, discarding jagged values.
• tail : this function returns a list minus the first element of the list on which tail is performed.
• foldLeft : combines the elements of the list together with a seed value (in my case I use a target List).
• reverse : reverses the order of the list.

so here is the code to do this:

object SumPairs extends Application {

val numbers = List(1,2,3,4,5);
val result = numbers.zip(numbers.tail)
             .foldLeft(List[Int]()) (
                (list, y) => {
                   y._1 + y._2 :: list
                }
              )
             .reverse;
println(result);

}

Basically this works as follows:

1. I create a List of Tuples of each adjacent value in the List by getting the tail of the List.
2. I get each Tuple in the list, sum it and prepend it to the List returned by "foldLeft".
3. I reverse the List to fix the order as a result of doing a prepend.

Now this is is designed to be functional but not overly complex (at least I hope not), Since I'm still fairly green in the Scala dark arts I'd like to hear on improvements.

BTW the challenge I'm talking about can be found here.

UPDATE:

Another solution would be to use List.flatMap which basically takes a function which returns an Iterable and appends it to a function, it pretty similar, It's maybe a little more concise, I'll let you decide:

val numbers = List(1,2,3,4,5);
numbers.zip(numbers.tail).flatMap {
     value => {
          List(value._1+value._2);
      }
};