Idiomatic way to "loop until"

[Andreas Joseph Krogh]

What is the most idiomatic way to do this in Scala?

val l = List(1,2,3,4)
val i = l.iterator
var cont = true
while (i.hasNext) {
        val k = i.next()
        if (isValid(k)) {
                val result = doStuff(k)
                if (result.stopProcessing) {
                        cont = false
                }
        }
}

I know takeWhile exists but I don't need to return anything.

 

Thanks.

 

--
Andreas Joseph Krogh <and...@officenet.no>      mob: +47 909 56 963
Senior Software Developer / CTO - OfficeNet AS - http://www.officenet.no
Public key: http://home.officenet.no/~andreak/public_key.asc

[Dennis Haupt]

make a method out of your code and attach it to all collections via implicits :)

or:

list.view.takeWhile(...).foreach(...)

 

Gesendet: Montag, 24. Juni 2013 um 09:57 Uhr
Von: "Andreas Joseph Krogh" <and...@officenet.no>
An: scala...@googlegroups.com
Betreff: [scala-user] Idiomatic way to "loop until"

--
You received this message because you are subscribed to the Google Groups "scala-user" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-user+...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
 
 

[Dennis Haupt]

you can also foreach & break out of it

 

Gesendet: Montag, 24. Juni 2013 um 10:02 Uhr
Von: "Dennis Haupt" <h-s...@gmx.de>
An: "Andreas Joseph Krogh" <and...@officenet.no>
Cc: scala...@googlegroups.com
Betreff: Aw: [scala-user] Idiomatic way to "loop until"

[Lanny Ripple]

I would do

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

    .iterator

    .takeWhile(isValid(_))

    .map{doStuff(_)}

    .takeWhile(!_.stopProcessing)

    .foreach{_ => ()}

The clunky foreach{} is in case your doStuff() uses a lot of resources and trying to force the iterator with .toList would overflow something.

Your code works just fine though.  Put it all behind a def and forget about it.

  def foreachWithStop[A,B](xs: Iterable[A], trans: A => B, stopWhen: B => Boolean)

[Alexandru Nedelcu]

On Mon, Jun 24, 2013 at 10:57 AM, Andreas Joseph Krogh and...@officenet.no wrote:

What is the most idiomatic way to do this in Scala?

Here's another version:

@tailrec
def loop(l: List[Int]) {
  val cont = l match {
    case head :: tail if isValid(head) =>
      !doStuff(head).stopProcessing
    case head :: tail =>
      true
    case Nil =>
      false
  }

  if (cont) loop(l.tail)
}

—
Alexandru Nedelcu
https://bionicspirit.com

[Andreas Joseph Krogh]

Nice, thanks!

[Josh Suereth]

Perhaps a simpler version....

list.iterator takeWhile isValid takeWhile (x => !doStuff(x).stopProcessing)

*or* a more familiar syntax..

list.iterator.takeWhile(isValid).takeWhile(x => !doStuff(x).stopProcessing)


*OR* maybe lazier?

list.iterator takeWhile { x =>
  isValid(x) && !doStuff(x).stopProcessing
}

Hope that helps :)

- Josh

--

[Alexandru Nedelcu]

On Wed, Jul 3, 2013 at 3:15 AM, Josh Suereth <joshua....@gmail.com> wrote:

list.iterator takeWhile { x =>
  isValid(x) && !doStuff(x).stopProcessing
}

In his example, the loop does not break on the first isValid(x) that fails.

The loop simply skips all invalid items, until it finds one that isValid but that wants to stopProcessing.

--
Alexandru Nedelcu
https://bionicspirit.com

[Josh Suereth]

Ah, my bad.  Had misread.  SO then:

list.iterator filter isValid takeWhile { x =>
  !doStuff(x).stopProcessing

[Josh Suereth]

Also, technically the original loop (as written) just goes through everything in the iterator, since done doesn't show up in a condition.  I assume he wanted early exit by the description.

[Alexandru Nedelcu]

On Wed, Jul 3, 2013 at 5:27 PM, Josh Suereth <joshua....@gmail.com> wrote:

Also, technically the original loop (as written) just goes through everything in the iterator, since done doesn't show up in a condition.

I've missed that too :-) I also misread "cond" as an early exit.