Is Scala idiomatic coding style just a cool trap for writing inefficient code?

Question

I sense that the Scala community has a little big obsession with writing \"concise\", \"cool\", \"scala idiomatic\", \"one-liner\" -if possible- code. This

Answer 1

Try this:

(myList.foldLeft((List[Int](), None: Option[Int]))) {
  case ((_, None),     x) => (List(),               Some(x))
  case ((Nil, Some(m), x) => (List(Math.min(x, m)), Some(Math.max(x, m))
  case ((l, Some(m),   x) => (Math.min(x, m) :: l,  Some(Math.max(x, m))
})._1

Idiomatic, functional, traverses only once. Maybe somewhat cryptic if you are not used to functional-programming idioms.

Let's try to explain what is happening here. I will try to make it as simple as possible, lacking some rigor.

A fold is an operation on a List[A] (that is, a list that contains elements of type A) that will take an initial state s0: S (that is, an instance of a type S) and a function f: (S, A) => S (that is, a function that takes the current state and an element from the list, and gives the next state, ie, it updates the state according to the next element).

The operation will then iterate over the elements of the list, using each one to update the state according to the given function. In Java, it would be something like:

interface Function { R apply(T t); }
class Pair { ... }
 State fold(List list, State s0, Function, State> f) {
  State s = s0;
  for (A a: list) {
    s = f.apply(new Pair(a, s));
  }
  return s;
}

For example, if you want to add all the elements of a List[Int], the state would be the partial sum, that would have to be initialized to 0, and the new state produced by a function would simply add the current state to the current element being processed:

myList.fold(0)((partialSum, element) => partialSum + element)

Try to write a fold to multiply the elements of a list, then another one to find extreme values (max, min).

Now, the fold presented above is a bit more complex, since the state is composed of the new list being created along with the maximum element found so far. The function that updates the state is more or less straightforward once you grasp these concepts. It simply puts into the new list the minimum between the current maximum and the current element, while the other value goes to the current maximum of the updated state.

What is a bit more complex than to understand this (if you have no FP background) is to come up with this solution. However, this is only to show you that it exists, can be done. It's just a completely different mindset.

EDIT: As you see, the first and second case in the solution I proposed are used to setup the fold. It is equivalent to what you see in other answers when they do xs.tail.fold((xs.head, ...)) {...}. Note that the solutions proposed until now using xs.tail/xs.head don't cover the case in which xs is List(), and will throw an exception. The solution above will return List() instead. Since you didn't specify the behavior of the function on empty lists, both are valid.