Scalaz（57）－ scalaz-stream: fs2-多线程编程，fs2 concurrency

最新推荐文章于 2024-05-12 09:41:02 发布
最新推荐文章于 2024-05-12 09:41:02 发布
阅读量687 收藏 1
点赞数
分类专栏： 编程技术 Scala Scalaz 泛函编程（Functional Programming) 文章标签： 编程 scala scalaz functional programmi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TIGER_XC/article/details/52325885
版权

    fs2的多线程编程模式不但提供了无阻碍I/O（java nio）能力，更为并行运算提供了良好的编程工具。在进入并行运算讨论前我们先示范一下fs2 pipe2对象里的一些Stream合并功能。我们先设计两个帮助函数（helper）来跟踪运算及模拟运算环境：

  def log[A](prompt: String): Pipe[Task,A,A] = _.evalMap {a =>
    Task.delay { println(prompt + a); a}}         //> log: [A](prompt: String)fs2.Pipe[fs2.Task,A,A]

  Stream(1,2,3).through(log(">")).run.unsafeRun   //> >1
                                                  //| >2
                                                  //| >3


log是个运算跟踪函数。 

 implicit val strategy = Strategy.fromFixedDaemonPool(4)
  //> strategy  : fs2.Strategy = Strategy
 implicit val scheduler = Scheduler.fromFixedDaemonPool(2)
  //> scheduler  : fs2.Scheduler = Scheduler(java.util.concurrent.ScheduledThreadPoolExecutor@16022d9d[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0])
  def randomDelay[A](max: FiniteDuration): Pipe[Task, A, A] = _.evalMap { a => {
    val delay: Task[Int] = Task.delay {
      scala.util.Random.nextInt(max.toMillis.toInt)
    }
    delay.flatMap { d => Task.now(a).schedule(d.millis) }
   }
  }      //> randomDelay: [A](max: scala.concurrent.duration.FiniteDuration)fs2.Pipe[fs2.Task,A,A]
  Stream(1,2,3).through(randomDelay(1.second)).through(log("delayed>")).run.unsafeRun
                                                  //> delayed>1
                                                  //| delayed>2
                                                  //| delayed>3


randomDelay是一个模拟任意延迟运算环境的函数。我们也可以在连接randomDelay前后进行跟踪： 

Stream(1,2,3).through(log("befor delay>"))
               .through(randomDelay(1.second))
               .through(log("after delay>")).run.unsafeRun
                                                  //> befor delay>1
                                                  //| after delay>1
                                                  //| befor delay>2
                                                  //| after delay>2
                                                  //| befor delay>3
                                                  //| after delay>3


值得注意的是randomDelay并不会阻碍（block）当前运算。

下面我们来看看pipe2对象里的合并函数interleave：

val sa = Stream(1,2,3).through(randomDelay(1.second)).through(log("A>"))
        //> sa  : fs2.Stream[fs2.Task,Int] = Segment(Emit(Chunk(1, 2, 3))).flatMap(<function1>).flatMap(<function1>)
val sb = Stream(1,2,3).through(randomDelay(1.second)).through(log("B>"))
        //> sb  : fs2.Stream[fs2.Task,Int] = Segment(Emit(Chunk(1, 2, 3))).flatMap(<function1>).flatMap(<function1>)
(sa interleave sb).through(log("AB")).run.unsafeRun
                                                  //> A>1
                                                  //| B>1
                                                  //| AB>1
                                                  //| AB>1
                                                  //| A>2
                                                  //| B>2
                                                  //| AB>2
                                                  //| AB>2
                                                  //| A>3
                                                  //| B>3
                                                  //| AB>3
                                                  //| AB>3


我们看到合并后的数据发送必须等待sa,sb完成了元素发送之后。这是一种固定顺序的合并操作。merge是一种不定顺序的合并方式，我们看看它的使用示范： 

(sa merge sb).through(log("AB>")).run.unsafeRun   //> B>1
                                                  //| AB>1
                                                  //| B>2
                                                  //| AB>2
                                                  //| B>3
                                                  //| AB>3
                                                  //| A>1
                                                  //| AB>1
                                                  //| A>2
                                                  //| AB>2
                                                  //| A>3
                                                  //| AB>3


我们看到merge不会同时等待sa,sb完成后再发送结果，只要其中一个完成发送就开始发送结果了。换言之merge合并基本上是跟着跑的快的那个，所以结果顺序是不规则不可确定的（nondeterministic）。那么从运算时间上来讲：interleave合并所花费时间就是确定的sa+sb，而merge则选sa,sb之间最快的时间。当然总体运算所需时间是相当的，但在merge时我们可以对发出的元素进行并行运算，能大大缩短运算时间。用merge其中一个问题是我们无法确定当前的元素是从那里发出的，我们可以用either来解决这个问题： 

(sa either sb).through(log("AB>")).run.unsafeRun  //> A>1
                                                  //| AB>Left(1)
                                                  //| B>1
                                                  //| AB>Right(1)
                                                  //| A>2
                                                  //| AB>Left(2)
                                                  //| B>2
                                                  //| AB>Right(2)
                                                  //| B>3
                                                  //| AB>Right(3)
                                                  //| A>3
                                                  //| AB>Left(3)


我们通过left,right分辨数据源头。如果再增多一个Stream源头，我们还是可以用merge来合并三个Stream： 

val sc = Stream.range(1,10).through(randomDelay(1.second)).through(log("C>"))
    //> sc  : fs2.Stream[fs2.Task,Int] = Segment(Emit(Chunk(()))).flatMap(<function1>).flatMap(<function1>).flatMap(<function1>)
((sa merge sb) merge sc).through(log("ABC>")).run.unsafeRun
                                                  //> B>1
                                                  //| ABC>1
                                                  //| C>1
                                                  //| ABC>1
                                                  //| A>1
                                                  //| ABC>1
                                                  //| B>2
                                                  //| ABC>2
                                                  //| A>2
                                                  //| ABC>2
                                                  //| B>3
                                                  //| ABC>3
                                                  //| C>2
                                                  //| ABC>2
                                                  //| A>3
                                                  //| ABC>3
                                                  //| C>3
                                                  //| ABC>3
                                                  //| C>4
                                                  //| ABC>4
                                                  //| C>5
                                                  //| ABC>5
                                                  //| C>6
                                                  //| ABC>6
                                                  //| C>7
                                                  //| ABC>7
                                                  //| C>8
                                                  //| ABC>8
                                                  //| C>9
                                                  //| ABC>9


如果我们无法确定数据源头数量的话，那么我们可以用以下的类型款式来表示： 

Stream[Task,Stream[Task,A]]


这个类型代表的是Stream of Streams。在外部的Stream里包含了不确定数量的Streams。用具体的例子可以解释：外部的Stream代表客端数据连接（connection），内部的Stream代表每个客端读取的数据。把上面的三个Stream用这种类型来表示的话： 

val streams:Stream[Task,Stream[Task,Int]] = Stream(sa,sb,sc)
     //> streams  : fs2.Stream[fs2.Task,fs2.Stream[fs2.Task,Int]] = Segment(Emit(Chunk(Segment(Emit(Chunk(1, 2, 3))).flatMap(<function1>).flatMap(<function1>),Segment(Emit(Chunk(1, 2, 3))).flatMap(<function1>).flatMap(<function1>), S
egment(Emit(Chunk(()))).flatMap(<function1>).flatMap(<function1>).flatMap(<function1>))))


现在我们不但需要对内部Stream进行运算还需要把结果打平成Stream[Task,A]。在fs2.concurrent包里就有这样一个组件（combinator）： 

  def join[F[_],O](maxOpen: Int)(outer: Stream[F,Stream[F,O]])(implicit F: Async[F]): Stream[F,O] = {...}


输入参数outer和运算结果类型都对得上。maxOpen代表最多并行运算数。我们可以用join运算上面合并sa,sb,sc的例子： 

val ms = concurrent.join(3)(streams)              //> ms  : fs2.Stream[fs2.Task,Int] = attemptEval(Task).flatMap(<function1>).flatMap(<function1>)
ms.through(log("ABC>")).run.unsafeRun             //> C>1
                                                  //| ABC>1
                                                  //| A>1
                                                  //| ABC>1
                                                  //| C>2
                                                  //| ABC>2
                                                  //| B>1
                                                  //| ABC>1
                                                  //| C>3
                                                  //| ABC>3
                                                  //| A>2
                                                  //| ABC>2
                                                  //| B>2
                                                  //| ABC>2
                                                  //| C>4
                                                  //| ABC>4
                                                  //| A>3
                                                  //| ABC>3
                                                  //| B>3
                                                  //| ABC>3
                                                  //| C>5
                                                  //| ABC>5
                                                  //| C>6
                                                  //| ABC>6
                                                  //| C>7
                                                  //| ABC>7
                                                  //| C>8
                                                  //| ABC>8
                                                  //| C>9
                                                  //| ABC>9


结果就是我们预料的。上面提到过maxOpen是最大并行运算数。我们用另一个例子来观察： 

val rangedStreams = Stream.range(0,5).map {id =>
      Stream.range(1,5).through(randomDelay(1.second)).through(log((('A'+id).toChar).toString +">")) }
      //> rangedStreams  : fs2.Stream[Nothing,fs2.Stream[fs2.Task,Int]] = Segment(Emit(Chunk(()))).flatMap(<function1>).mapChunks(<function1>)
concurrent.join(3)(rangedStreams).run.unsafeRun   //> B>1
                                                  //| A>1
                                                  //| C>1
                                                  //| B>2
                                                  //| C>2
                                                  //| A>2
                                                  //| B>3
                                                  //| C>3
                                                  //| C>4
                                                  //| D>1
                                                  //| A>3
                                                  //| A>4
                                                  //| B>4
                                                  //| E>1
                                                  //| E>2
                                                  //| E>3
                                                  //| D>2
                                                  //| D>3
                                                  //| E>4
                                                  //| D>4


可以看到一共只有三个运算过程同时存在，如：ABC, ED...

当我们的程序需要与外界程序交互时，可能会以下面的几种形式进行：

1、产生副作用的运算是同步运行的。这种情况最容易处理，因为直接可以获取结果

2、产生副作用的运算是异步的：通过调用一次callback函数来提供运算结果

3、产生副作用的运算是异步的，但结果必须通过多次调用callback函数来分批提供

下面我们就一种一种情况来分析：

1、同步运算最容易处理：我们只需要把运算包嵌在Stream.eval里就行了：

def destroyUniverse: Unit = println("BOOOOM!!!")  //> destroyUniverse: => Unit
val s = Stream.eval_(Task.delay(destroyUniverse)) ++ Stream("...move on")
    //> s  : fs2.Stream[fs2.Task,String] = append(attemptEval(Task).flatMap(<function1>).flatMap(<function1>), Segment(Emit(Chunk(()))).flatMap(<function1>))
s.runLog.unsafeRun                        //> BOOOOM!!!
                                          //| res8: Vector[String] = Vector(...move on)


2、第二种情况：fs2里的Async trait有个async是用来登记callback函数的： 

trait Async[F[_]] extends Effect[F] { self =>
/**
   Create an `F[A]` from an asynchronous computation, which takes the form
   of a function with which we can register a callback. This can be used
   to translate from a callback-based API to a straightforward monadic
   version.
   */
  def async[A](register: (Either[Throwable,A] => Unit) => F[Unit]): F[A] =
    bind(ref[A]) { ref =>
    bind(register { e => runSet(ref)(e) }) { _ => get(ref) }}
...

我们用一个实际的例子来做示范，假设我们有一个callback函数readBytes：

trait Connection {
  def readBytes(onSuccess: Array[Byte] => Unit, onFailure: Throwable => Unit): Unit

这个Connection就是一个交互界面（interface）。假设它是这样实现实例化的：

val conn = new Connection {
  def readBytes(onSuccess: Array[Byte] => Unit, onFailure: Throwable => Unit): Unit = {
    Thread.sleep(1000)
    onSuccess(Array(1,2,3,4,5))
  }
}  //> conn  : demo.ws.fs2Concurrent.connection = demo.ws.fs2Concurrent$$anonfun$main$1$$anon$1@4c40b76e

我们可以用async登记（register）这个callback函数，把它变成纯代码可组合的（monadic）组件Task[Array[Byte]]： 

val bytes = T.async[Array[Byte]] { (cb: Either[Throwable,Array[Byte]] => Unit) => {
   Task.delay { conn.readBytes (
     ready => cb(Right(ready)),
     fail => cb(Left(fail))
   ) }
}}             //> bytes  : fs2.Task[Array[Byte]] = Task

这样我们才能用Stream.eval来运算bytes： 

Stream.eval(bytes).map(_.toList).runLog.unsafeRun //> res9: Vector[List[Byte]] = Vector(List(1, 2, 3, 4, 5))


这种只调用一次callback函数的情况也比较容易处理：当我们来不及处理数据时停止读取就是了。如果需要多次调用callback，比如外部程序也是一个Stream API：一旦数据准备好就调用一次callback进行传送。这种情况下可能出现我们的程序来不及处理收到的数据的状况。我们可以用fs2.async包提供的queue来解决这个问题： 

import fs2.async
  import fs2.util.Async

  type Row = List[String]
  // defined type alias Row

  trait CSVHandle {
    def withRows(cb: Either[Throwable,Row] => Unit): Unit
  }
  // defined trait CSVHandle

  def rows[F[_]](h: CSVHandle)(implicit F: Async[F]): Stream[F,Row] =
    for {
      q <- Stream.eval(async.unboundedQueue[F,Either[Throwable,Row]])
      _ <- Stream.suspend { h.withRows { e => F.unsafeRunAsync(q.enqueue1(e))(_ => ()) }; Stream.emit(()) }
      row <- q.dequeue through pipe.rethrow
    } yield row
  // rows: [F[_]](h: CSVHandle)(implicit F: fs2.util.Async[F])fs2.Stream[F,Row]


enqueue1和dequeue在Queue trait里是这样定义的： 

/**
 * Asynchronous queue interface. Operations are all nonblocking in their
 * implementations, but may be 'semantically' blocking. For instance,
 * a queue may have a bound on its size, in which case enqueuing may
 * block until there is an offsetting dequeue.
 */
trait Queue[F[_],A] {
/**
   * Enqueues one element in this `Queue`.
   * If the queue is `full` this waits until queue is empty.
   *
   * This completes after `a`  has been successfully enqueued to this `Queue`
   */
  def enqueue1(a: A): F[Unit]

/** Repeatedly call `dequeue1` forever. */
  def dequeue: Stream[F, A] = Stream.repeatEval(dequeue1)

  /** Dequeue one `A` from this queue. Completes once one is ready. */
  def dequeue1: F[A]
...


我们用enqueue1把一次callback调用存入queue。dequeue的运算结果是Stream[F,Row]，所以我们用dequeue运算存在queue里的任务取出数据。

fs2提供了signal,queue,semaphore等数据类型。下面是一些使用示范：async.signal

Stream.eval(async.signalOf[Task,Int](0)).flatMap {s =>
    val monitor: Stream[Task,Nothing] =
      s.discrete.through(log("s updated>")).drain
    val data: Stream[Task,Int] =
      Stream.range(10,16).through(randomDelay(1.second))
    val writer: Stream[Task,Unit] =
      data.evalMap {d => s.set(d)}
    monitor merge writer
  }.run.unsafeRun                                 //> s updated>0
                                                  //| s updated>10
                                                  //| s updated>11
                                                  //| s updated>12
                                                  //| s updated>13
                                                  //| s updated>14
                                                  //| s updated>15


async.queue使用示范: 

Stream.eval(async.boundedQueue[Task,Int](5)).flatMap {q =>
    val monitor: Stream[Task,Nothing] =
      q.dequeue.through(log("dequeued>")).drain
    val data: Stream[Task,Int] =
      Stream.range(10,16).through(randomDelay(1.second))
    val writer: Stream[Task,Unit] =
      data.to(q.enqueue)
    monitor mergeHaltBoth  writer

  }.run.unsafeRun                                 //> dequeued>10
                                                  //| dequeued>11
                                                  //| dequeued>12
                                                  //| dequeued>13
                                                  //| dequeued>14
                                                  //| dequeued>15


fs2还在time包里提供了一些定时自动产生数据的函数和类型。我们用一些代码来示范它们的用法： 

 time.awakeEvery[Task](1.second)
   .through(log("time:"))
   .take(5).run.unsafeRun                         //> time:1002983266 nanoseconds
                                                  //| time:2005972864 nanoseconds
                                                  //| time:3004831159 nanoseconds
                                                  //| time:4002104307 nanoseconds
                                                  //| time:5005091850 nanoseconds


awakeEvery产生的是一个无穷数据流，所以我们用take(5)来取前5个元素。我们也可以让它运算5秒钟： 

 val tick = time.awakeEvery[Task](1.second).through(log("time:"))
    //> tick  : fs2.Stream[fs2.Task,scala.concurrent.duration.FiniteDuration] = Segment(Emit(Chunk(()))).flatMap(<function1>).flatMap(<function1>).flatMap(<function1>)
 tick.run.unsafeRunFor(5.seconds)                 //> time:1005685270 nanoseconds
                                                  //| time:2004331473 nanoseconds
                                                  //| time:3005046945 nanoseconds
                                                  //| time:4002795227 nanoseconds
                                                  //| time:5002807816 nanoseconds
                                                  //| java.util.concurrent.TimeoutException


如果我们希望避免TimeoutException，可以用Task.schedule: 

val tick = time.awakeEvery[Task](1.second).through(log("time:"))
   //> tick  : fs2.Stream[fs2.Task,scala.concurrent.duration.FiniteDuration] = Seg
ment(Emit(Chunk(()))).flatMap(<function1>).flatMap(<function1>).flatMap(<function1>)
 tick.interruptWhen(Stream.eval(Task.schedule(true,5.seconds)))
      .run.unsafeRun                              //> time:1004963839 nanoseconds
                                                  //| time:2005325025 nanoseconds
                                                  //| time:3005238921 nanoseconds
                                                  //| time:4004240985 nanoseconds
                                                  //| time:5001334732 nanoseconds
                                                  //| time:6003586673 nanoseconds
                                                  //| time:7004728267 nanoseconds
                                                  //| time:8004333608 nanoseconds
                                                  //| time:9003907670 nanoseconds
                                                  //| time:10002624970 nanoseconds


最直接的方法是用fs2的tim.sleep： 

 (time.sleep[Task](5.seconds) ++ Stream.emit(true)).runLog.unsafeRun
                                                  //> res14: Vector[Boolean] = Vector(true)
 tick.interruptWhen(time.sleep[Task](5.seconds) ++ Stream.emit(true))
    .run.unsafeRun                                //> time:1002078506 nanoseconds
                                                  //| time:2005144318 nanoseconds
                                                  //| time:3004049135 nanoseconds
                                                  //| time:4002963861 nanoseconds
                                                  //| time:5000088103 nanoseconds



























TIGER_XC
关注
专栏目录
fs2-blobstore：最小，惯用的基于流的Scala接口，用于键值存储实现
02-05
fs2-blobstore 最小，惯用的基于流的Scala接口，用于键/值存储实现。 它为由不同持久性机制（例如S3，FileSystem，sftp等）支持的类似于S3的键/值存储提供了抽象。 正在安装 将fs2-blobstore部署到Maven Central，添加到build.sbt中： libraryDependencies ++= Seq( "com.lendup.fs2-blobstore" %% "core" % "0.6.+", "com.lendup.fs2-blobstore" %% "sftp" % "0.6.+", "com.lendup.fs2-blo
中子：基于Fs2构建的纯功能性Scala Apache Pulsar客户端
02-05
中子：基于Fs2构建的纯功能性Scala Apache Pulsar客户端
Scalaz（55）－ scalaz-stream: fs2-基础介绍，fs2 stream transformation
weixin_30640769的博客
08-24 145
fs2是scalaz-stream的最新版本，沿用了scalaz-stream被动式（pull model）数据流原理但采用了全新的实现方法。fs2比较scalaz-stream而言具备了：更精简的基础组件（combinator）、更安全的类型、资源使用（type safe, resource safety）、更高的运算效率。由于fs2基本沿用了scalaz-stream的原理，...
探秘FS2：纯粹的函数式Scala流处理库
最新发布
gitblog_00079的博客
05-12 340
探秘FS2：纯粹的函数式Scala流处理库 项目地址:https://gitcode.com/typelevel/fs2 在Scala编程世界中，我们总是追求更高效、更安全和更具表达力的工具。这就是FS2应运而生的原因——一个为Scala量身打造的功能性、有影响的且多态的流处理库。其设计思想是组合性、表达力、资源安全性以及速度。让我们一起深入了解一下这个强大而富有创新的开源项目。 项目介绍 FS2...
Scalaz（56）－ scalaz-stream: fs2-安全运算，fs2 resource safety
TIGER_XC的专栏
08-25 630
fs2在处理异常及资源使用安全方面也有比较大的改善。fs2 Stream可以有几种方式自行引发异常：直接以函数式方式用fail来引发异常、在纯代码里隐式引发异常或者在运算中引发异常，举例如下： /函数式 val err = Stream(1,2,3) ++ Stream.fail(new Exception("oh,no...")) //> err : fs2.Stream[Nothi
Scalaz（54）－ scalaz-stream: 函数式多线程编程模式－Free Streaming Programming Model
TIGER_XC的专栏
08-19 648
长久以来，函数式编程模式都被认为是一种学术研究用或教学实验用的编程模式。直到近几年由于大数据和多核CPU的兴起造成了函数式编程模式在一些实际的大型应用中的出现，这才逐渐改变了人们对函数式编程无用论的观点。通过一段时间对函数式编程方法的学习，我们了解到Free Monad的算式／算法关注分离（separation of concern）可以是一种很实用的函数式编程模式。用Free Monad编写的程
Scalaz（58）－ scalaz-stream: fs2-并行运算示范，fs2 parallel processing
TIGER_XC的专栏
08-30 1074
从表面上来看，Stream代表一连串无穷数据元素。一连串的意思是元素有固定的排列顺序，所以对元素的运算也必须按照顺序来：完成了前面的运算再跟着进行下一个元素的运算。这样来看，Stream应该不是很好的并行运算工具。但是，fs2所支持的并行运算方式是以完整的Steam为运算单位的：支持多个Stream同时进行运算，如merge。所以fs2使Stream的并行运算成为了可能。
scalaz-stream-contrib:scalaz-stream 的附加进程
06-12
scalaz-stream-贡献 安装 resolvers + = " Frank's Bintray " at " https://dl.bintray.com/fthomas/maven " libraryDependencies + = " eu.timepit " %% " scalaz-stream-contrib " % " <version>
streamz:一个用于集成Scala（FS2），Akka Streams和Apache Camel的功能流的组合器库
03-07
Streamz Streamz提供了用于集成（FS2）， 和组合器库。 他们整合 带有Akka Streams的Apache Camel： Camel端点可以通过的集成到Akka Stream应用程序中。 带有FS2的Apache Camel：可以使用将Camel端点集成到FS2应用程序中。 带有FS2的Akka流：可将Akka流Source ， Flow和Sink分别转换为FS2 Stream ， Pipe和Sink ，反之亦然，使用。 依存关系 Streamz工件可用于Scala 2.12和2.13，网址为： resolvers += Resolver.bintrayRepo("streamz", "maven") val streamzVersion = "0.13" libraryDependencies ++= Seq( "com.github.krasserm" %
scalaz-and-cats：Scalaz和Cats之间的用法示例和基准（w Haskell Ground-truth）
02-04
本项目"scalaz-and-cats"专注于对比这两者的用法，同时通过Haskell作为“Ground-truth”来提供参考，因为Haskell作为纯函数式语言，其类型系统和库设计往往被认为是函数式编程的最佳实践。 **Scalaz** Scalaz是...
sparse:scalaz-stream 的广义增量解析器组合器
07-03
import scalaz . std . anyVal . _ import scalaz . stream . _ import scalaz . stream . parsers . _ import Parser . _ // returns the depth of parentheses nesting lazy val parens : Parser [ Char , Int ] ...
scalaz-core_2.9.3-7.1.0-RC2.zip
09-26
总结来说，"scalaz-core_2.9.3-7.1.0-RC2.zip"和"play-twenty-three.zip"代表了Scala生态系统中的两个关键部分：一个强大的函数式编程库和一个基于Play Framework的JSON处理项目。理解并熟练运用这些工具，可以帮助...
scalaz-contrib:Scalaz 的互操作性库和附加数据结构和实例
06-08
scalaz-贡献 Scalaz 的互操作性库和附加数据结构和实例 用法 该库目前仅适用于 Scala 2.11。 对于 2.10 版本，请使用版本0.1.5 。 要使用最新版本，请在build.sbt包含以下build.sbt ： libraryDependencies ++ = ...
fs库的功能_具有超级功能的流媒体库：FS2和功能编程
07-29 1457
fs库的功能Scala has a very special streaming library called FS2 (Functional Streams for Scala). This library embodies all the advantages of functional programming (FP). By understanding its design goals y...
Scalaz（39）－ Free ：a real monadic program
TIGER_XC的专栏
04-18 3100
一直感觉FP比较虚，可能太多学术性的东西。不知道如何把这些数学理论在背后支持的一套全新数据类型和数据结构在现实开发中加以使用。直到Free Monad，才真正感觉能用FP方式进行编程了。这次我想跟大家讨论一下用Free Monad来编写一个真正能运行的完整应用程序。当然，这个程序必须具备FP特性，比如函数组合（function composition）,纯代码（pure code），延迟副作用（d
Scalaz（38）－ Free ：Coproduct－Monadic语句组合
TIGER_XC的专栏
04-12 2586
很多函数式编程爱好者都把FP称为Monadic Programming，意思是用Monad进行编程。我想FP作为一种比较成熟的编程模式，应该有一套比较规范的操作模式吧。因为Free能把任何F[A]升格成Monad，所以Free的算式（AST）、算法（Interpreter）关注分离（separation of concern）应用模式应该可以成为一种规范的FP编程模式。我们在前面的几篇讨论中都涉及
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值