Can I use a fold function to implement pack functionality? - scala

Question

I'm working on the following problem:
Pack consecutive duplicates of list elements into sublists. If a list
contains repeated elements they should be placed in separate sublists.
Example:
scala> pack(List('a, 'a, 'a, 'a, 'b, 'c, 'c, 'a, 'a, 'd, 'e, 'e, 'e,
'e)) res0: List[List[Symbol]] = List(List('a, 'a, 'a, 'a), List('b),
List('c, 'c), List('a, 'a), List('d), List('e, 'e, 'e, 'e))
I am wondering whether it can be implemented using foldRight. So far I can only make a recursive solution like below work:
def pack(list: List[Char]) = {
def checkNext(a: List[List[Char]], prev: Char, l: List[Char]): List[List[Char]] = l match {
case Nil => a
case h::tail if h == prev => checkNext((h::a.head)::a.tail,h,tail)
case h::tail => checkNext(List(h)::a,h,tail)
}
checkNext(List(List[Char](list.last)), list.last, list.init.reverse)
}

Answer 1

Absolutely! I find it to be very natural to use folds to accumulate a complex result from iterating a sequence. Essentially, it works the same as what you're doing now, except the matching on the list is provided to you by fold, and you just provide the processing for the cases. I'm not sure if you wanted an actual answer, so I'll try to give you a couple hints.
Think of the type of your final result. Now think of what value of that type would be the result of applying your process to an empty sequence. That's your first argument to foldRight/foldLeft.
Now you have to define what to do to extend your accumulator for each item you process. It seems to me you have two cases: either you've encountered a new letter that you haven't seen before or you're adding another instance to an existing list. You can use some fancy matching to detect which case you're in.
Here's how I'd do it:
def pack(list: List[Char]) = list.foldLeft(List.empty[List[Char]]) { case (acc, next) =>
acc.headOption.flatMap(_.headOption) match {
case Some(x) if x == next => (acc.head :+ next) +: acc.tail
case _ => List(next) +: acc
}
}.reverse
I used flatMap to join the two checks for whether there's a list at all yet and whether the a list for the current character exists. I find foldLeft to be more intuitive and it also has the added benefit of being tail recursive on List.
The result:
scala> pack(List('a', 'a', 'a', 'a', 'b', 'c', 'c', 'a', 'a', 'd',
'e', 'e', 'e', 'e'))
res1: List[List[Char]] = List(List(a, a, a, a),
List(b), List(c, c), List(a, a), List(d), List(e, e, e, e))

Answer 2

Here is my version of fold:
def pack[A](xs: List[A]): List[List[A]] =
xs.foldRight(List[List[A]]()){
case (x, (ys#(y::_)) :: rs) if x == y => (x::ys) :: rs
case (x, ys) => List(x) :: ys
}
However, I prefer the recursive one:
def pack2[A](xs: List[A]): List[List[A]] = xs match {
case Nil => Nil
case x::_ => val (hs, ts) = xs.span(x==); hs::pack2(ts)
}
The recursive one is clearer and shorter than the fold version, in addition it is faster!
scala> def time(n: Int)(call : => Unit): Long = {
| var cnt = 0
| val start = System.currentTimeMillis
| while(cnt < n) {
| cnt += 1
| call
| }
| System.currentTimeMillis - start
| }
time: (n: Int)(call: => Unit)Long
scala> val xs = ("A"*100 + "B"*1000 + "C"*10 + "DEFGH"*1000).toList
xs: List[Char] = List(A, A, A...)
scala> time(10000){ pack(xs) }
res3: Long = 19961
scala> time(10000){ pack2(xs) }
res4: Long = 4382
And named #acjay's version as pack3:
scala> def pack3(list: List[Char]) = list.foldLeft(List.empty[List[Char]]) { case (acc, next) =>
| acc.headOption.flatMap(_.headOption) match {
| case Some(x) if x == next => (acc.head :+ next) +: acc.tail
| case _ => List(next) +: acc
| }
| }.reverse
pack3: (list: List[Char])List[List[Char]]
scala> time(10000){ pack3(xs) }
res5: Long = 420946
scala> pack3(xs) == pack2(xs)
res6: Boolean = true
scala> pack3(xs) == pack(xs)
res7: Boolean = true

Answer 3

Implementation by Martin Odersky
def pack[T](xs: List[T]): List[List[T]] = xs match{
case Nil => Nil
case x :: xs1 =>
val (first, rest) = xs span (y => y == x)
first :: pack(rest)
}