Écrire générique takeWhile avec un décalage dans Scala

Question

J'ai un cas d'utilisation pour takeWhile, mais où je veux garder un nombre fixe d'éléments après que le prédicat est vrai. J'essaie aussi de l'écrire pour être aussi générique que possible pour le type de collection. Donc, quelque chose comme:

def takeWhileWithOffset[A, Iter[_] <: Iterable[A]](iter: Iter[A], p: A => Boolean, offset: Int) 

J'ai choisi Iterable comme la limite, parce que veulent qu'il fonctionne avec Stream. Mais j'ai du mal à comprendre comment faire ce travail. Si j'utilisais une collection stricte, je pourrais utiliser dropRight si le décalage n'est pas positif. Mais Iterable n'a pas dropRight.

Le cas positif est plus délicat. Je pourrais utiliser sliding pour saisir efficacement les futurs éléments, puis utiliser init et lastOption après la takeWhile se termine. Mais Iterable n'a pas init et lastOption.

Alors ce qui est difficile est que je veux que ma méthode pour être paresseux, mais tirer profit du fait que réitérés articles peuvent être traités comme une collection stricte - mais seulement si les takeWhile se termine. Y a-t-il un moyen de faire cela?

Answer 1

span et take:

scala> val it = (1 to 100).iterator 
it: Iterator[Int] = non-empty iterator        

scala> val (a, b) = it.span(_ < 10) 
a: Iterator[Int] = non-empty iterator 
b: Iterator[Int] = unknown-if-empty iterator 

scala> val res = a ++ b.take(5) 
res: Iterator[Int] = non-empty iterator 

scala> res.toList 
res0: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)