Q:

Functional way to map over a list with an accumulator in Scala

I would like to write succinct code to map over a list, accumulating a value as I go and using that value in the output list.
Using a recursive function and pattern matching this is straightforward (see below). But I was wondering if there is a way to do this using the function programming family of combinators like map and fold etc. Obviously map and fold are no good unless you use a mutable variable defined outside the call and modify that in the body.
Perhaps I could do this with a State Monad but was wondering if there is a way to do it that I'm missing, and that utilizes the Scala standard library.
// accumulate(List(10, 20, 20, 30, 20))
// => List(10, 30, 50, 80, 100,)

def accumulate(weights : List[Int], sum : Int = 0, acc: List[Int] = List.empty) : List[Int] = {
  weights match {
    case hd :: tl =>
      val total = hd + sum
      accumulate(tl, total, total :: acc)
    case Nil =>
      acc.reverse
  }
}

A:

You may also use foldLeft:
def accumulate(seq: Seq[Int]) =
  seq.foldLeft(Vector.empty[Int]) { (result, e) =>
    result :+ result.lastOption.getOrElse(0) + e
  }

accumulate(List(10, 20, 20, 30, 20))
// => List(10, 30, 50, 80, 100,)

A:

This could be done with scan:
val result = list.scanLeft(0){case (acc, item) => acc+item}

Scan will include the initial value 0 into output so you have to drop it:
result.drop(1)

A:

As pointed out in @Nyavro's answer, the operation you are looking for (the sum of the prefixes of the list) is called prefix-sum and its generalization to any binary operation is called scan and is included in the Scala standard library:
val l = List(10, 20, 20, 30, 20)

l.scan(0) { _ + _ }
//=> List(0, 10, 30, 50, 80, 100)

l.scan(0)(_ + _).drop(1)
//=> List(10, 30, 50, 80, 100)

This has already been answered, but I wanted to address a misconception in your question:

Obviously map and fold are no good unless you use a mutable variable defined outside the call and modify that in the body.

That is not true. fold is a general method of iteration. Everything you can do by iterating over a collection, you can do with fold. If fold were the only method in your List class, you could still do everything you can do now. Here's how to solve your problem with fold:
l.foldLeft(List(0)) { (list, el) ⇒ list.head + el :: list }.reverse.drop(1)

And a general implementation of scan:
def scan[A](l: List[A])(z: A)(op: (A, A) ⇒ A) = 
  l.
    drop(1).
    foldLeft(List(l.head)) { (list, el) ⇒ op(list.head, el) :: list }.
    reverse

Think of it this way: a collection can be either empty or not. fold has two arguments, one which tells it what to do when the list is empty, and one which tells it what to do when the list is not empty. Those are the only two cases, so every possible case is handled. Therefore, fold can do anything! (More precisely in Scala, foldLeft and foldRight can do anything, while fold is restricted to associative operations.)
Or a different viewpoint: a collection is a stream of instructions, either the EMPTY instruction or the ELEMENT(value) instruction. foldLeft / foldRight are skeleton interpreters for that instruction set, and you as a programmer can supply the implementation for the interpretation of both those instructions, namely the two arguments to foldLeft / foldRight are the interpretation of those instructions.
Remember: while foldLeft / foldRight reduces a collection to a single value, that value can be arbitrarily complex, including being a collection itself!

