Scalaz(53)- scalaz-stream: 程序运算器-application scenario
从上面多篇的讨论中我们了解到scalaz-stream代表一串连续无穷的数据或者程序。对这个数据流的处理过程就是一个状态机器(state machine)的状态转变过程。这种模式与我们通常遇到的程序流程很相似:通过程序状态的变化来推进程序进展。传统OOP式编程可能是通过一些全局变量来记录当前程序状态,而FP则是通过函数组合来实现状态转变的。这个FP模式讲起来有些模糊和抽象,但实际上通过我们前面长时间对FP编程的学习了解到FP编程讲究避免使用任何局部中间变量,更不用说全局变量了。FP程序的数据A是包嵌在算法F[A]内的。FP编程模式提供了一整套全新的数据更新方法来实现对F[A]中数据A的操作。对许多编程人员来讲,FP的这种编程方式会显得很别扭、不容易掌握。如果我们仔细观察分析,会发觉scalaz-stream就是一种很好的FP编程工具:它的数据也是不可变的(immutable),并且是包嵌在高阶类型结构里的,是通过Process状态转变来标示数据处理过程进展的。scalaz-stream的数据处理是有序流程,这样可以使我们更容易分析理解程序的运算过程,它的三个大环节包括:数据源(source),数据传换(transducer)及数据终点(Sink/Channel)可以很形象地描绘一个程序运算的全过程。scalaz-stream在运算过程中的并行运算方式(parallel computaion)、安全资源使用(resource safety)和异常处理能力(exception handling)是实现泛函多线程编程最好的支持。我们先来看看scalaz-stream里的一个典型函数:
/**
* Await the given `F` request and use its result.
* If you need to specify fallback, use `awaitOr`
*/
def await[F[_], A, O](req: F[A])(rcv: A => Process[F, O]): Process[F, O] =
awaitOr(req)(Halt.apply)(rcv)
/**
* Await a request, and if it fails, use `fb` to determine the next state.
* Otherwise, use `rcv` to determine the next state.
*/
def awaitOr[F[_], A, O](req: F[A])(fb: EarlyCause => Process[F, O])(rcv: A => Process[F, O]): Process[F, O] =
Await(req,(r: EarlyCause \/ A) => Trampoline.delay(Try(r.fold(fb,rcv))))
这个await函数可以说是一个代表完整程序流程的典范。注意,awaitOr里的Await是个数据结构。这样我们在递归运算await时可以避免StackOverflowError的发生。req: F[A]代表与外界交互的一个运算,如从外部获取输入、函数rcv对这个req产生的运算结果进行处理并设定程序新的状态。
import scalaz.stream._
import scalaz.concurrent._
object streamApps {
import Process._
def getInput: Task[Int] = Task.delay { } //> getInput: => scalaz.concurrent.Task[Int]
val prg = await(getInput)(i => emit(i * )) //> prg : scalaz.stream.Process[scalaz.concurrent.Task,Int] = Await(scalaz.concurrent.Task@4973813a,<function1>,<function1>)
prg.runLog.run //> res0: Vector[Int] = Vector(9)
}
这是一个一步计算程序。我们可以再加一步:
val add10 = await1[Int].flatMap{i => emit(i + )}
//> add10 : scalaz.stream.Process[[x]scalaz.stream.Process.Env[Int,Any]#Is[x],Int] = Await(Left,<function1>,<function1>)
val prg1 = await(getInput)(i => emit(i * ) |> add10)
//> prg1 : scalaz.stream.Process[scalaz.concurrent.Task,Int] = Await(scalaz.concurrent.Task@6737fd8f,<function1>,<function1>)
prg1.runLog.run //> res0: Vector[Int] = Vector(19)
add10是新增的一个运算步骤,是个transducer所以调用了Process1的函数await1,并用pipe(|>)来连接。实际上我们可以用组合方式(compose)把add10和prg组合起来:
val prg3 = prg |> add10 //> prg3 : scalaz.stream.Process[scalaz.concurrent.Task,Int] = Append(Halt(End) ,Vector(<function1>))
prg3.runLog.run //> res1: Vector[Int] = Vector(19)
我们同样可以增加一步输出运算:
val outResult: Sink[Task,Int] = sink.lift { i => Task.delay{println(s"the result is: $i")}}
//> outResult : scalaz.stream.Sink[scalaz.concurrent.Task,Int] = Append(Emit(Vector(<function1>)),Vector(<function1>))
val prg4 = prg1 to outResult //> prg4 : scalaz.stream.Process[[x]scalaz.concurrent.Task[x],Unit] = Append(Halt(End),Vector(<function1>, <function1>))
prg4.run.run //> the result is: 19
scalaz-stream的输出类型是Sink,我们用to来连接。那么如果需要不断重复运算呢:
import scalaz._
import Scalaz._
import scalaz.concurrent._
import scalaz.stream._
import Process._
object streamAppsDemo extends App {
def putLine(line: String) = Task.delay { println(line) }
def getLine = Task.delay { Console.readLine }
val readL = putLine("Enter:>").flatMap {_ => getLine}
val readLines = repeatEval(readL)
val echoLine = readLines.flatMap {line => eval(putLine(line))}
echoLine.run.run
}
这是一个无穷运算程序:不停地把键盘输入回响到显示器上。下面是一些测试结果:
Enter:>
hello world!
hello world!
Enter:>
how are you?
how are you?
Enter:>
当然,我们也可以把上面的程序表达的更形象些:
val outLine: Sink[Task,String] = constant(putLine _).toSource
val echoInput: Process[Task,Unit] = readLines to outLine
//echoLine.run.run
echoInput.run.run
用to Sink来表述可能更形象。这个程序没有任何控制:甚至无法有意识地退出。我们试着加一些控制机制:
def lines: Process[Task,String] = {
def go(line: String): Process[Task,String] =
line.toUpperCase match {
case "QUIT" => halt
case _ => emit(line) ++ await(readL)(go)
}
await(readL)(go)
} val prg = lines to outLine
prg.run.run
在rcv函数里检查输入是否quit,如果是就halt,否则重复运算await。现在可以控制终止程序了。
下面再示范一下异常处理机制:看看能不能有效的捕捉到运行时的错误:
def mul(i: Int) = await1[String].flatMap { s => emit((s.toDouble * i).toString) }.repeat
val prg = (lines |> mul()) to outLine
prg.run.run
加了个transducer mul(5),如果输入是可转变为数字类型的就乘5否者会异常退出。下面是一些测试场景:
Enter:> 25.0
Enter:> 30.0
Enter:>
six
Exception in thread "main" java.lang.NumberFormatException: For input string: "six"
at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:)
我们可以用onFailure来捕捉任何错误:
def mul(i: Int) = await1[String].flatMap { s => emit((s.toDouble * i).toString) }.repeat
//val prg = (lines |> mul(5)) to outLine
val prg = (lines |> mul()).onFailure { e => emit("invalid input!!!") } to outLine
prg.run.run
现在运算结果变成了下面这样:
Enter:> 25.0
Enter:> 30.0
Enter:>
six
invalid input!!!
证明我们捕捉并处理了错误。一个完整安全的程序还必须具备自动事后清理的功能。这项可以通过onComplete来实现:
def mul(i: Int) = await1[String].flatMap { s => emit((s.toDouble * i).toString) }.repeat
//val prg = (lines |> mul(5)) to outLine
val prg = (lines |> mul()).onFailure { e => emit("invalid input!!!") }
val prg1 = prg.onComplete{ Process.eval(Task.delay {println("end of program"); ""}) } to outLine
prg1.run.run
测试结果如下:
Enter:> 25.0
Enter:> 30.0
Enter:>
six
invalid input!!!
end of program
再有一个值得探讨的就是这些程序的组合集成。scalaz-stream就是存粹的泛函类型,那么基于scalaz-stream的程序就自然具备组合的能力了。我们可以用两个独立的程序来示范Process程序组合:
import scalaz._
import Scalaz._
import scalaz.concurrent._
import scalaz.stream._
import Process._
object prgStream extends App {
def prompt(prmpt: String) = Task.delay { print(prmpt) }
def putLine(line: String) = Task.delay { println(line) }
def getLine = Task.delay { Console.readLine }
val readLine1 = prompt("Prg1>:").flatMap {_ => getLine}
val readLine2 = prompt("Prg2>:").flatMap {_ => getLine}
val stdOutput = constant(putLine _).toSource
def multiplyBy(n: Int) = await1[String].flatMap {line =>
if (line.isEmpty) halt
else emit((line.toDouble * n).toString)
}.repeat
val prg1: Process[Task,String] = {
def go(line: String): Process[Task,String] = line.toUpperCase match {
case "QUIT" => halt
case _ => emit(line) ++ await(readLine1)(go)
}
await(readLine1)(go)
}.onComplete{ Process.eval(Task.delay {println("end of program1"); ""}) }
val prg2: Process[Task,String] = {
def go(line: String): Process[Task,String] = line.toUpperCase match {
case "QUIT" => halt
case _ => emit(line) ++ await(readLine2)(go)
}
await(readLine2)(go)
}.onComplete{ Process.eval(Task.delay {println("end of program2"); ""}) }
val program1 = (prg1 |> multiplyBy() to stdOutput)
val program2 = (prg2 |> multiplyBy() to stdOutput) (program1 ++ program2).run.run }
因为program的类型是Process[Task,String],所以我们可以用++把它们连接起来。同时我们应该看到在program的形成过程中transducer multiplyBy是如何用|>与prg组合的。现在我们看看测试运算结果:
Prg1>:
9.0
Prg1>:
12.0
Prg1>:quit
end of program1
Prg2>:
25.0
Prg2>:
30.0
Prg2>:quit
end of program2
我们看到程序是按照流程走的。下面再试个流程控制程序分发(dispatching)的例子:
val program1 = (prg1 |> multiplyBy() observe stdOutput)
val program2 = (prg2 |> multiplyBy() observe stdOutput) //(program1 ++ program2).run.run
val getOption = prompt("Enter your choice>:").flatMap {_ => getLine }
val mainPrg: Process[Task,String] = {
def go(input: String): Process[Task,String] = input.toUpperCase match {
case "QUIT" => halt
case "P1" => program1 ++ await(getOption)(go)
case "P2" => program2 ++ await(getOption)(go)
case _ => await(getOption)(go)
}
await(getOption)(go)
}.onComplete{ Process.eval(Task.delay {println("end of main"); ""}) } mainPrg.run.run
我们先把program1和program2的终点类型Sink去掉。用observe来实现数据复制分流。这样program1和program2的结果类型才能与await的类型相匹配。我们可以测试运行一下:
Enter your choice>:p2
Prg2>:
15.0
Prg2>:
25.0
Prg2>:quit
end of program2
Enter your choice>:p1
Prg1>:
9.0
Prg1>:
18.0
Prg1>:quit
end of program1
Enter your choice>:wat
Enter your choice>:oh no
Enter your choice>:quit
end of main
scalaz-stream是一种泛函类型。我们在上面已经示范了它的函数组合能力。当然,如果程序的类型是Process,那么我们可以很容易地用merge来实现并行运算。
scalaz-stream作为一种程序运算框架可以轻松实现FP程序的组合,那么它成为一种安全稳定的泛函多线程编程工具就会是很好的选择。
Scalaz(53)- scalaz-stream: 程序运算器-application scenario的更多相关文章
- 《java小应用程序(Applet)和java应用程序(Application)分别编写的简单计算器》
Application和Java Applet的区别.Java语言是一种半编译半解释的语言.Java的用户程序分为两类:Java Application和Java Applet.这两类程序在组成结构和 ...
- 《Java应用程序(Application)》
在编写Java应用程序(Application)时可以这样: 1,定义包名. 2, 导入相关的包. 3, 定义一个类. 4,定义相关变量. 5,定义构造函数.(在构造函数内调用init()方法和add ...
- delphi关闭程序Close,application.Terminate与halt区别
当Close是一个主窗体时,程序会退出.Close会发生FormClose事件,FormCloseQuery事件Halt会发生FormDestory事件,Application.Terminate以上 ...
- 【应用程序见解 Application Insights】Application Insights 使用 Application Maps 构建请求链路视图
Applicaotn Insigths 使用 Application Maps 构建请求链路视图 构建系统时,请求的逻辑操作大多数情况下都需要在不同的服务,或接口中完成整个请求链路.一个请求可以经历 ...
- 【Azure 事件中心】为应用程序网关(Application Gateway with WAF) 配置诊断日志,发送到事件中心
问题描述 在Application Gateway中,开启WAF(Web application firewall)后,现在需要把访问的日志输出到第三方分析代码中进行分析,如何来获取WAF的诊断日志呢 ...
- HTML5应用程序缓存Application Cache
什么是Application Cache HTML5引入了应用程序缓存技术,意味着web应用可进行缓存,并在没有网络的情况下使用,通过创建cache manifest文件,可以轻松的创建离线应用. A ...
- HTML5应用程序缓存Application Cache详解
什么是Application Cache HTML5引入了应用程序缓存技术,意味着web应用可进行缓存,并在没有网络的情况下使用,通过创建cache manifest文件,可以轻松的创建离线应用. A ...
- 在Ubuntu上为Android系统内置Java应用程序测试Application Frameworks层的硬件服务(老罗学习笔记6)
一:Eclipse下 1.创建工程: ---- 2.创建后目录 3.添加java函数 4.在src下创建package,在package下创建file 5.res---layout下创建xml文件,命 ...
- 为Android系统内置Java应用程序测试Application Frameworks层的硬件服务
我们在Android系统增加硬件服务的目的是为了让应用层的APP能够通过Java接口来访问硬件服务.那么, APP如何通过Java接口来访问Application Frameworks层提供的硬件服务 ...
随机推荐
- _学生选课数据库SQL语句练习题
1. 查询Student表中的所有记录的Sname.Ssex和Class列. select Sname,Ssex,t.sclass from STUDENT t 2. 查询教师所有的单位即不重复的De ...
- Mongodb 的基本使用
一.cmd连接mongodb 服务 进入mongodb的bin目录下:[D:\mongodb3.2.5\bin]$ mongo 127.0.0.1:27017 常用查询: show dbs 查看所有数 ...
- 跨域API
跨域API 简单跨域请求 只需要简单的设置允许跨域就可以了 def set_default_headers(self): self.set_header('Access-Control-Allow-O ...
- JTMz换路径导致MySQL服务不能启动的问题
问题: JTMz解压到我的机器上,运行一次后,把服务停止了,然后移到了另外一个路径,JTMz中自带的MySQL服务启动不起来了. 解决: 在注册表中修改 HKEY_LOCAL_MACHINE\SYST ...
- Socket实现仿QQ聊天(可部署于广域网)附源码(1)-简介
1.前言 本次实现的这个聊天工具是我去年c#程序设计课程所写的Socket仿QQ聊天,由于当时候没有自己的服务器,只能在机房局域网内进行测试,最近在腾讯云上买了一台云主机(本人学生党,腾讯云有个学生专 ...
- SQL Pass北京举办第11次线下活动,欢迎报名(本次活动特别邀请了来自微软总部Xin Jin博士)
活动主题: 探讨SQL Server 2014与Fusion IO在SQL Server中的应用 地点:北京微软(中国)有限公司[望京利星行],三层308室 时间:2013年 10 月19日 13:3 ...
- Cwinux源码解析(三)
我在我的 薛途的博客 上发表了新的文章,欢迎各位批评指正. Cwinux源码解析(三)
- 微信开发 -- 搭建基于ngrok的微信本地调试环境
第一步,安装ngrok客户端 (1)首先先到官网下载个客户端 http://natapp.cn/,选择适合的客户端类型,本人选择的是windows版 (2)下载后,解压,可以看到如下目录: 第二步,开 ...
- 使用office制作图章公章
制作公章的软件非常多,随便到网上一搜就有成千成百的软件或小工具,常用的有PS.Coreldraw.Ai.Word等,拥有一款office可以使用word来制作,方法挺简单,功能挺强大.寥寥数笔难以形容 ...
- CSS Vocabulary – CSS 词汇表,你都掌握了吗?
CSS 是前端开发必备技能,入门容易,深入难.比如像 Pseudo-class.Pseudo-element.Media query.Media type 以及 Vendor prefix 的概念,很 ...