Scala récursion sur plusieurs listes

Question

J'ai cette fonction qui prend deux listes et retourne la somme des deux listes.

Exemple:

def sumOfSums(a: List[Int], b: List[Int]): Int = { 
    var sum = 0 
    for(elem <- a) sum += elem 
    for(elem <- b) sum += elem 
    sum 
} 

assez simple, mais je suis maintenant essayer de le faire récursive et le second paramètre de liste me jetant.

Ce que j'ai jusqu'à présent:

def sumOfSumsRec(a: List[Int], b: List[Int], acc: Int): Int = a match { 
    case Nil => acc 
    case h :: t => sumOfSumsRec(t, acc + h) 
} 

Il y a 2 problèmes ici:

1. Je ne correspondant sur le 'a' List
2. Je reçois une erreur quand j'essaie de faire acc + h, je ne sais pas pourquoi.

Question: Comment puis-je itérer récursivement sur deux listes pour obtenir leur somme?

Answer 1

match Motif: les deux listes

import scala.annotation.tailrec 

def recSum(a: List[Int], b: List[Int]): Int = { 
    @tailrec 
    def recSumInternal(a: List[Int], b: List[Int], acc: Int): Int = { 
    (a, b) match { 
     case (x :: xs, y :: ys) => recSumInternal(xs, ys, x + y + acc) 
     case (x :: xs, Nil) => recSumInternal(xs, Nil, x + acc) 
     case (Nil, y :: ys) => recSumInternal(Nil, ys, y + acc) 
     case _ => acc 
    } 
    } 
    recSumInternal(a, b, 0) 
} 

test:

recSum(List(1,2), List(3,4,5)) 

Rendement:

15 

Side note:

Pour tout Futurs lecteurs de ce post, j'ai supposé que cette question était principalement posée à des fins éducatives, montrant ainsi comment la récursivité peut fonctionner sur plusieurs listes, mais ce n'est pas une façon idiomatique de prendre. Pour d'autres fins, par tous les moyens:

scala> val a = List(1,2) 
a: List[Int] = List(1, 2) 

scala> val b = List(3,4,5) 
b: List[Int] = List(3, 4, 5) 

scala> a.sum + b.sum 
res0: Int = 15 

Ou envisager d'utiliser des mécanismes tels que foldLeft, foldMap, etc.