Observations

  implicit class StreamOfResults[T](source: Stream[Result[T]]) {
    def |>[U](op: T ⇒ Result[U]) = source map (t ⇒ t flatMap op)
    def filter(p: T ⇒ Outcome) = source |> (x => p(x) andThen Good(x))
    def map[U](f: T ⇒ U) = source map (_ map f)
  }

  implicit class StreamOfResults[T](source: Stream[Result[T]]) {
    def |>[U](op: T ⇒ Result[U]) = source map (t ⇒ t flatMap op)
    def filter(p: T ⇒ Result[_]) = source |> (x ⇒ p(x) returning x)
    def map[U](f: T ⇒ U) = source map (_ map f)
  }

  // this method could be written in a couple of lines, but it's better to keep the details
  def streamOfNewEobSelectors(): StreamOfResults[Element] = {
    // this function pairs an html element with its content
    def withContent(e: Element): Result[(Element, String)] = e.outerHtml() map ((e, _))

    // here we have a stream of elements paired with their content
    val pairs: StreamOfResults[(Element, String)] = streamOfEobElements |> withContent

    // here we filter the stream, leaving only the elements containing new stuff
    // note that the stuff we don't need is not kicked out, it's labeled as bad with an explanation
    val newOnes: StreamOfResults[(Element, String)]] = pairs filter (p => isNewClaim(p._2))

    // here we forget the html
    newOnes map {case p:(Element, String) => p._1}
  }

trait TimeReader {

  def currentTime: Long = System.currentTimeMillis

  def flowOfTime = Iterator.iterate(currentTime){_ => currentTime}

  def interval(n:Long) = {
    flowOfTime.next // the first drop, may be stale
    val end = flowOfTime.next + n
    flowOfTime takeWhile (end >)
  }

  def interval(duration: Duration) = interval(duration.toMillis)
  //...

for {i <- 1 to 10; t <- interval(1 second) } {Thread.sleep(1); println(s"$i @$t") }

for {
  val value ← cached(source:Something, ttl: Duration)
} doStuff(value)

  for {
    val value0 ← (source:Stream[T]) // a stream
    val value ← cache(ttl: Duration)(value0)
  } doStuff(value)

  for {
    val value0 ← (source:Stream[T]) // a stream
    val value ← cache(ttl: Duration, timeSource: TimeReader = StandardTime/*we have this class*/)(value0)
  } doStuff(value)

scala> sealed trait Nat
defined trait Nat

scala> case object Z extends Nat { override def toString = "0" }
defined module Z

scala> case class S(n:Nat) extends Nat { override def toString = (n.toString.toInt + 1).toString }
defined class S

scala> def pred(n:Nat) = n match {
     | case Z => Z
     | case S(x) => x
     | }
pred: (n: Nat)Nat

scala> pred(S(S(S(S(Z)))))
res3: Nat = 3