# 泛函编程（20）－泛函库设计－Further Into Parallelism

`1 def sequence[A](lp: List[Par[A]]): Par[List[A]]`

`1 def parMap[A,B](l: List[A])(f: A => B): Par[List[B]]`

parMap按List[A]产生了一串并行运算的函数f。我们可以从类型匹配着手一步一步推导：

1、lp: List[Par[B]] = l.map(asyncF(f))

2、pl: Par[List[B]] = sequence(lp) >>> parMap

`1 def parFilter[A](as: List[A])(f: A => Boolean): Par[List[A]]`

我们还是从类型匹配着手一步步推导：

1、asyncF( a => if(f(a)) List(a) else List() )  >>> Par[List[A]]

2、lpl: List[Par[List[A]]] = as.map( asyncF( a => if(f(a)) List(a) else List()))

3、pll: Par[List[List[A]]] = sequence(lpl)

4、map(pll){ a => a.flatten } >>> Par[List{A]]

```1   def parFilter[A](as: List[A])(f: A => Boolean): Par[List[A]] = {
2        val pars: List[Par[List[A]]] = as.map(asyncF( (a: A) => if (f(a)) List(a) else List() ))
3        map(sequence(pars)){ a => a.flatten }
4   }                                               //> parFilter: [A](as: List[A])(f: A => Boolean)ch71.Par.Par[List[A]]```

``` 1 parFilter(List(10,29,13,3,6,48)){_ > 10}(es).get//> pool-1-thread-1
18                                                   //| res0: List[Int] = List(29, 13, 48)```

1、"the quick fox".split(' ').size >>> 把字符串分解成文字并计算数量

2、List(A,B,C) >>> A.size + B.size + C.size >>> 把List里的文字数积合。

1. f: A => B >>> 我们需要把这个函数转成并行运算：List[Par[B]]

2. g: List[B] => B

``` 1   def generalWordCount[A,B](as: List[A])(f: A => B)(g: List[B] => B): Par[B] = {
2       val lp: List[Par[B]] = as.map(asyncF(f))
3       val pl: Par[List[B]] = sequence(lp)
4       map(pl)(g)
5   }                                               //> generalWordCount: [A, B](as: List[A])(f: A => B)(g: List[B] => B)ch71.Par.P
6                                                   //| ar[B]
7   def wordCount(as: List[String]): Par[Int] = {
8       generalWordCount(as)(_.split(' ').size)(_.sum)
9   }                                               //> wordCount: (as: List[String])ch71.Par.Par[Int]
10   val lw = List("the quick silver fox", "is running","the one legged fog", "is hopping")
11                                                   //> lw  : List[String] = List(the quick silver fox, is running, the one legged
12                                                   //| fog, is hopping)
13   wordCount(lw)(es).get                           //> pool-1-thread-1
24                                                   //| res7: Int = 12```

```1   val es = Executors.newFixedThreadPool(1)
2   val a = fork(async(40+2))
3   run(es)(a).get```

```1     def fork[A](pa: => Par[A]): Par[A] = {
2         es => {
3             es.submit(new Callable[A] {
4               def call: A = run(es)(pa).get
5             })
6         }
7     }```

`1   def choice[A](pa: Par[Boolean])(ifTrue: Par[A], ifFalse: Par[A]): Par[A]`

```1   def choice[A](pa: Par[Boolean])(ifTrue: Par[A], ifFalse: Par[A]): Par[A] = {
2       es => if(run(es)(pa).get) run(es)(ifTrue) else run(es)(ifFalse)
3   }```

ppa: Par[Par[A]]， 如果 run(es)(ppa).get 得到 pa: Par[A], 再run(es)(pa) >>> Future[A]。 Par[A] = es => Future[A]，不就解决问题了嘛：

```1   def join[A](ppa: Par[Par[A]]): Par[A] = {
2       es => {
3           run(es)(run(es)(ppa).get())
4       }
5   }```

`1   def choiceN[A](pb: Par[Int])(choices: List[Par[A]]): Par[A]`

run(es)(pb).get 得出指数(index), choices(index)就是选择的运算了：

```1   def choiceN[A](pb: Par[Int])(choices: List[Par[A]]): Par[A] = {
2       es => {
3           run(es)(choices(run(es)(pb).get))
4       }
5   }```

`1   def flatMap[A,B](pa: Par[A])(f: A => Par[B]): Par[B]`

```1   def flatMap[A,B](pa: Par[A])(f: A => Par[B]): Par[B] = {
2       es => {
3           run(es)(f(run(es)(pa).get))
4       }
5   }```

```1   def choiceByFlatMap[A](pb: Par[Boolean])(ifTrue: Par[A], ifFalse: Par[A]): Par[A] ={
2     flatMap(pb){a => if (a) ifTrue else ifFalse }
3   }
4   def choiceNByFlatMap[A](pb: Par[Int])(choices: List[Par[A]]): Par[A] = {
5       flatMap(pb){choices(_)}
6   }```

```1   def joinByFlatMap[A](ppa: Par[Par[A]]): Par[A] = {
2       flatMap(ppa){(x: Par[A]) => x}
3   }
4   def flatMapByJoin[A,B](pa: Par[A])(f: A => Par[B]): Par[B] = {
5       join(map(pa)(f))
6   }
7   def mapByFlatMap[A,B](pa: Par[A])(f: A => B): Par[B] = {
8       flatMap(pa) { a => unit(f(a)) }
9   }```

210 篇文章59 人订阅

0 条评论

## 相关文章

### 高通msm8909耳机调试

1、DTS相应修改： DTS相关代码：kernel/arch/arm/boot/dts/qcom/msm8909-qrd-skuc.dtsi： 1 s...

8045

2122

### App Guide相关

##TourGuide https://github.com/worker8/TourGuide

812

2608

### 高通Audio中ASOC的machine驱动

ASoC被分为Machine、Platform和Codec三大部分，其中的Machine驱动负责Platform和Codec之间的耦合以及部分和设备或板子特定的...

1K4

1082

### Html5模拟通讯录人员排序（sen.js）

// JavaScript Document  var PY_Json_Str = ""; var PY_Str_1 = ""; var PY_Str_...

6346

### 2018年SCI期刊最新影响因子排行，最高244，人工智能TPAMI9.455

2018年6月26日，最新的SCI影响因子正式发布，涵盖1万2千篇期刊。CA-Cancer J Clin 依然拔得头筹，其影响因子今年再创新高，达244.585...

1472

2943

2752