Apply element to successive elements in a List - scala

Question

I'm looking for a way to apply each element in a List with its successive elements in Scala without writing a nested for loop. Basically I'm looking for a List comprehension that allows me to do the following:
Let
A = {a, b, c, d}
Then A' = {ab, ac, ad, bc, bd, cd}
I thought about using map for example, A.map(x => ...), but I can't figure out how the rest of the statement would look.
Hopefully this all makes sense. Any help would be greatly appreciated.

Answer 1

This seems a natural for a recursive evaluation. since it's prepend the first element to the rest of the list, then follow with the same thing applied to the rest of the list.
def pairs(xs: List[Char]): List[String] = xs match {
case Nil | _ :: Nil => Nil
case y :: ys => ys.map(z => s"$y$z") ::: pairs(ys)
}
pairs(a) //> res0: List[String] = List(ab, ac, ad, bc, bd, cd)
Tail recursive
def pairs2(xs: List[Char], acc:List[String]): List[String] = xs match {
case Nil | _ :: Nil => acc.reverse
case y :: ys => pairs2(ys, ys.foldLeft(acc){(acc, z) => s"$y$z"::acc})
}
pairs2(a, Nil) //> res0: List[String] = List(ab, ac, ad, bc, bd, cd)
Or if you really want a comprehension:
val res = for {(x::xs) <- a.tails
y <- xs
}
yield s"$x$y"
(returns an iterator, so force its evaluation)
res.toList //> res1: List[String] = List(ab, ac, ad, bc, bd, cd)
which suggests yet another variant, from desugaring
a.tails.collect{case(x::xs) => xs.map(y=>s"$x$y")}.flatten.toList
//> res2: List[String] = List(ab, ac, ad, bc, bd, cd)

Answer 2

Remembering that in Scala what we have is a 'for-comprehension' rather than a 'for-loop' in the Java sense, the construction isn't "nested" in the same sense as it would be in Java. Specifically, it would look something like:
// For a list of items of some type 'A':
val items: List[A] = ???
// and some suitable combining function (which might be inlined if simple enough):
def fn(i1: A, i2: A): A = ???
// an example for-comprehension that will achieve the output you describe:
for {
x <- items.zipWithIndex
y <- items.zipWithIndex
z <- List(fn(x._1, y._1)) if (x._2 < y._2)
} yield z
which seems clean enough to me. This de-sugars to something like:
items.zipWithIndex.flatMap( x =>
items.zipWithIndex.flatMap( y =>
List(fn(x._1, y._1)).withFilter( z => x._2 < y._2 ).map( z => z ) ) )
which while being much more along the lines of the "List comprehension" you specifically asked for, seems less clear to read to me!

Answer 3

If you are combining Strings you could do something like this.
scala> List("a","b","c","d").combinations(2).map(s => s.head+s.last).toList
res5: List[String] = List(ab, ac, ad, bc, bd, cd)
But you refer to it as "a way to apply each element" so maybe you mean something else? If so, perhaps this approach could get you started.