Staged Sinks (just a lame cofree).

CanSink.scala

trait CanSink[First, Now, Final, To] {
  def result[E](in: StagedSink[First, E, Final], f: E => Now): To
  def result2[E](in: StagedSink[First, E, Final], f: E => TraversableOnce[Now]): To
}
trait LowPrioritySinkImplicits {
  implicit def sinkChain[First, E, Final]: CanSink[First, E, Final, StagedSink[First, E, Final]] = ???
}
object CanSink extends LowPrioritySinkImplicits {
  implicit def finalSink[First, E]: CanSink[First, E,E, Sink[First]] = ???
}

example.scala

object Example {
  class User {
     def livesIn(in: String): Boolean = true
     def name: String = "Josh"
  }

  object stdout extends  Sink[String] {
    override def apply(in: String): Unit = System.out.println(in);
  }
  def userSink: Sink[User] =
    for {
      user <- stdout.stage[User]
      if user livesIn "pittsburgh"
    } yield user.name
	
  def result = for {
    user <- List(new User)
  } userSink(user)
}

sink.scala

trait Sink[To] {
  def apply(t: To): Unit
  def stage[E]: StagedSink[E, E, To] = ???
}

StagedSink.scala

trait StagedSink[First, Current, Final] {
  def map[B, To](f: Current => B)(implicit isDone: CanSink[First, B, Final, To]): To
  def flatMap[B, To](f: Current => TraversableOnce[B])(implicit isDone: CanSink[First, B, Final, To]): To
  def withFilter(f: Current => Boolean): StagedSink[First, Current,Final]
}