Example: Fast exponentiation, streamingly 🌊

[jiribenes]

Tiny & fast exponentiation using streams:

The approach is simple: to calculate n^k, zip squares of n (n, n^2, n^4, ...) with the bits of k.
Sketch:

n^k = n^0b10011
    = (1 * n^0b10000)
    * (0 * n^0b01000)
    * (0 * n^0b00100)
    * (1 * n^0b00010)
    * (1 * n^0b00001)

Also drags a few other changes along:

• product and iterate in stream
• temporary addition of eachLSB and eachMSB -- these would probably be better off using the toolchain from Stdlib: Binary/Byte stream utilities #923, but I don't want to forget about the example

I'm adding it because:

1. it's a fun, small example,
2. it uses a bunch of different combinators,
3. it uses the new multiple param lambda case syntax (Allow lambda case patterns for multiple parameters #914),
4. and it has some missed opt opportunities, I think.

[jiribenes]

This part is just my sanity check for eachLSB and eachMSB. I'm happy to (re)move it after rebasing on top of #923 :)

[jiribenes]

Taken verbatim from #923, I really ought to rebase :)

By the way, as an exercise in algorithms, notice that the pow here and the fastexp above are completely isomorphic, always doing the exact same steps :)

[jiribenes]

TODO(Self):
add digits as an example & add related stream functions, maybe with an additional cheeky leftPad example? :^)

def takeWhile[A] { cond: A => Bool } { stream: => Unit / emit[A] }: Unit / emit[A] =
  try stream() with emit[A] {
    case value and cond(value) => do emit(value); resume(())
    case _                     => ()
  }

def last[A] { stream: => Unit / emit[A] }: A / Exception[MissingValue] = {
  var latest = None()
  for[A] {stream} { value =>
    latest = Some(value)
  }
  latest.value
}

def digits(n: Int) = last[Indexed[Int]] {
  with index[Int]
  with takeWhile { k => k <= n }
  iterate(1) { k => k * 10 }
}.index + 1

def main() = {
  with on[MissingValue].report
  println(digits(12345)) // ~> 5
}

[b-studios]

Nice... This looks a lot like unfolding a coalgebra :)

[jiribenes]

Yep, I just wanted to use the Haskell-style name which (weirdly!) is a bit friendlier than unfold