Scalaz（49）－ scalaz-stream: 深入了解-Sink/Channel

一个完整的scalaz-stream有以下几个部分组成：Source -> Transducer -> Sink，用直白文字来描述就是：“输入 -> 传换 -> 输出”。我们已经在前面几篇讨论中介绍了Source和Transducer的基本情况，这篇讨论我们探讨一下Sink。scalaz-stream最基本的功能就是从Source接收一串元素，经过处理然后输出。毕竟我们从外部获取了数据、处理完毕后总不能就留在原地内存，还是要把数据输出到对当前运算中程序来说的一个外部系统。Sink就等于是这个外部系统的输入接口。与往常一样，我们先来看看Sink的类型款式：

 /**
   * An effectful sink, to which we can send values. Modeled
   * as a source of effectful functions.
   */
  type Sink[+F[_],-O] = Process[F, O => F[Unit]]

从类型款式看来Sink就是一种Process。只不过它包含的元素是一串函数（O => F[Unit]）。这里的O是数据元素，F[Unit]的意思是对O进行F运算后不返回任何结果，如：Task{ println(...)}。我们先构造一个简单的Sink：

 val sinkStdout: Sink[Task,String] =
    Process.repeatEval {
       Task.delay { (s: String) =>
         Task.delay { println(s) }}}               //> sinkStdout  : scalaz.stream.Sink[scalaz.concurrent.Task,String] = Append(Await(scalaz.concurrent.Task@702b8b12,<function1>,<function1>),Vector(<function1>))

  val sinkStdout2: Sink[Task,String] =
    Process.constant { (s: String) =>
    Task.delay { println(s) }}                     //> sinkStdout2  : scalaz.stream.Sink[scalaz.concurrent.Task,String] = Append(Emit(Vector(<function1>)),Vector(<function1>))

我们应该怎样把数据传给Sink呢？首先我们可以用tee.zip：

  (range(,) zip sinkStdout).flatMap {
    case (i,f) => eval (f(i.toString))
  }.run.run                                        //> 1
                                                   //| 2
                                                   //| 3
                                                   //| 4
                                                   //| 5

实际上scalaz-stream提供了to函数来支持Sink连接。to还是通过tee.zip来实现的：

  /** Feed this `Process` through the given effectful `Channel`. */
    def through[F2[x]>:F[x],O2](f: Channel[F2,O,O2]): Process[F2,O2] =
      self.zipWith(f)((o,f) => f(o)).eval onHalt { _.asHalt }
  /** Attaches `Sink` to this  `Process`  */
    def to[F2[x]>:F[x]](f: Sink[F2,O]): Process[F2,Unit] =
      through(f)

我们用to来重复示范上面的例子：

 (range(,).map(_.toString) to sinkStdout).run.run
                                                   //> 1
                                                   //| 2
                                                   //| 3
                                                   //| 4
                                                   //| 5

可以说用to表述更简洁。如果我们需要把数据发送到多个外部系统，那我们就必须连接多个Sink了，可以用zip来连接多个Sink：

  (range(,) zip sinkStdout zip sinkStdout2).flatMap {
    case (((i,f),f2)) => for {
      _ <- eval(f(i.toString))
      _ <- eval(f2(i.toString))
    } yield ()
  }.run.run                                        //> 1
                                                   //| 1
                                                   //| 2
                                                   //| 2
                                                   //| 3
                                                   //| 3
                                                   //| 4
                                                   //| 4
                                                   //| 5
                                                   //| 5

scalaz-stream提供的observe函数可以像一个分流器一样安插在数据流中间复制一份数据发送到一个Sink而不影响正在流动的数据：

 (range(,).map(_.toString) observe sinkStdout observe sinkStdout2 to sinkStdout)
 .run.run                                          //> 1
                                                   //| 1
                                                   //| 1
                                                   //| 2
                                                   //| 2
                                                   //| 2
                                                   //| 3
                                                   //| 3
                                                   //| 3

以上例子相当于连接了3个Sink。observe通常被用来跟踪流中数据，因为它不会影响数据流的正常运算。我们也可以把多个Sink zip成一个多功能的Sink。与上面例子不同的是它只有一个输出口：

 import scalaz._
 import Scalaz._
 import scalaz.stream._
 import scalaz.concurrent._
 import scala.language.higherKinds
 object streamLogDemo {
   sealed trait Loglevel
   case object Info extends Loglevel
   case object Debug extends Loglevel
   case object Warning extends Loglevel

   case class Line(level: Loglevel, line: String)
   //Sinks
   val outInfo = io.stdOutLines.contramap {(l: Line) => "Info: " + l.line}
                                                   //> outInfo  : scalaz.stream.Channel[scalaz.concurrent.Task,Line,Unit] = Append(Emit(Vector(<function1>)),Vector(<function1>))
   val outDebug = io.stdOutLines.contramap {(l: Line) => "Debug: " + l.line}
                                                   //> outDebug  : scalaz.stream.Channel[scalaz.concurrent.Task,Line,Unit] = Append(Emit(Vector(<function1>)),Vector(<function1>))
   val outWarning = io.stdOutLines.contramap {(l: Line) => "Warning: " + l.line}
                                                   //> outWarning  : scalaz.stream.Channel[scalaz.concurrent.Task,Line,Unit] = Append(Emit(Vector(<function1>)),Vector(<function1>))

   val zippedSink = (outInfo zip outDebug zip outWarning).map {
     case ((fInfo,fDebug), fWarning) =>
       (l: Line) => l.level match {
         case Info    => fInfo(l)
         case Debug   => fDebug(l)
         case Warning => fWarning(l)
       }
   }                                               //> zippedSink  : scalaz.stream.Process[[x]scalaz.concurrent.Task[x],Line => scalaz.concurrent.Task[Unit]] = Append(Halt(End),Vector(<function1>))
   //test data
   val lines: List[Line] = List(
     Line(Info, "Hello"),
     Line(Debug, "buddy"),
     Line(Warning, "nanana"))                      //> lines  : List[Line] = List(Line(Info,Hello), Line(Debug,buddy), Line(Warning,nanana))
   //test run
   (Process.emitAll(lines) to zippedSink).run.run  //> Info: Hello
                                                   //| Debug: buddy
                                                   //| Warning: nanana
  }

仔细观察我们可以发现上面的例子里outInfo,outDebug,outWarning的最终类型变成了Channel，io.stdOutLines的类型应该是Sink，那么Channel应该是某种Sink了。我们看看Channel的类型款式：

/**
   * An effectful sink, to which we can send values. Modeled
   * as a source of effectful functions.
   */
  type Sink[+F[_],-O] = Process[F, O => F[Unit]]

  /**
   * An effectful channel, to which we can send values and
   * get back responses. Modeled as a source of effectful
   * functions.
   */
  type Channel[+F[_],-I,O] = Process[F, I => F[O]]

从类型款式上对比Sink和Channel的不同之处只在这个与外界系统的接口函数：Channel的函数是I => F[O]，它返回了F运算结果。这也很容易理解：Sink正如其名，任何东西进入Sink就如泥牛入海，无所回应。Channel会返回接收数据方的信息。Sink和Channel之间是可以相互转换的。Channel有个lift函数，能把一个A => F[B]函数升格成Channel类型：

 /** Promote an effectful function to a `Channel`. */
  def lift[F[_],A,B](f: A => F[B]): Channel[F, A, B] =
    Process constant f

实际上我如果用这个lift把A => F[Unit]这样的函数升格，就会得到一个Sink了。这个从Sink的lift函数中可以证实：

object sink {

  /** Promote an effectful function to a `Sink`. */
  def lift[F[_], A](f: A => F[Unit]): Sink[F, A] = channel lift f

}

我们用一些例子来体验一下：

  val ch = channel.lift((i: Int) => Task.delay { i *  })
                                                   //> ch  : scalaz.stream.Channel[scalaz.concurrent.Task,Int,Int] = Append(Emit(Vector(<function1>)),Vector(<function1>))
   (Process.range(,) through ch).runLog.run      //> res0: Vector[Int] = Vector(3, 6, 9, 12, 15)
   val sn = channel.lift((i: Int) => Task.delay { println(i * );()})
                                                   //> sn  : scalaz.stream.Channel[scalaz.concurrent.Task,Int,Unit] = Append(Emit(Vector(<function1>)),Vector(<function1>))
   (Process.range(,) to sn).run.run              //> 3
                                                   //| 6
                                                   //| 9
                                                   //| 12
                                                   //| 15
   val sn1 = sink.lift((i: Int) => Task.delay { println(i * ) })
                                                   //> sn1  : scalaz.stream.Sink[scalaz.concurrent.Task,Int] = Append(Emit(Vector(<function1>)),Vector(<function1>))
   (Process.range(,) to sn1).run.run             //> 3
                                                   //| 6
                                                   //| 9
                                                   //| 12
                                                   //| 15

如果我们的系统需要与外部多个系统对接的话，我们同样可以把一个数据源发送到多个Sink和Channel：

 (Process.range(,) observe sn observe sn1 through ch).runLog.run
                                                   //> 3
                                                   //| 3
                                                   //| 6
                                                   //| 6
                                                   //| 9
                                                   //| 9
                                                   //| 12
                                                   //| 12
                                                   //| 15
                                                   //| 15
                                                   //| res1: Vector[Int] = Vector(3, 6, 9, 12, 15)