```行令编程模式（imperative programming）
def au(t:T): T      async update with result
val t2 = au(t1)
val t3 = au(t2)
val t4 = au(t2 + t3)         t4 = ???```

```monadic programming : program with monads
val fp3 = F[p1] ⊕ F[p1] ⊕ F[p1] = F[p1+p2+p3]
1、延迟运算 ：val res = fp3.run
2、按序运算 ：flatMap{a => flatMap{b => flatMap{c =>… ```

``` case class Tube[A](run: A) {
def map[B](f: A => B): Tube[B] = Tube(f(run))
def flatMap[B](f: A => Tube[B]): Tube[B] = f(run)
}

val value: Tube[Int] = Tube(10)
def add(a: Int, b: Int): Tube[Int] = Tube(a+b)

val f = for {
a <- value
} yield c

println(f)          //Tube(23)
println(f.run)      //23```

```  val value: Option[Int] = Some(10)
def add(a: Int, b: Int): Option[Int] = Some(a+b)

val p = for {
a <- value
_ <- None
} yield a

println(p)     //None

val value: Either[String,Int] = Right(10)
def add(a: Int, b: Int): Either[String,Int] = Right(a+b)

val p = for {
a <- value
_ <- Left("oh no ...")
} yield c

println(p)  //oh no ...```

```  class KVStore[K,V] {
private val s = new ConcurrentHashMap[K,V]()
def create(k: K, v: V): Future[Boolean] = Future.successful(s.putIfAbsent(k,v) == null)
def read(k: K): Future[Option[V]] = Future.successful(Option(s.get(k)))
def update(k: K, v: V): Future[Unit] = Future.successful(s.put(k,v))
def delete(k: K): Future[Boolean] = Future.successful(s.remove(k) == null)
}```

``` type FoodName = String
type Quantity = Int
type FoodStore = KVStore[String,Int]

def addFood(food: FoodName, qty: Quantity )(implicit fs: FoodStore): Future[Unit] = for {
newQty = current.map(cq => cq + qty ).getOrElse(qty)
_ <-  fs.update(food, newQty)
} yield ()

def takeFood(food: FoodName, qty: Quantity)(implicit fs: FoodStore): Future[Quantity] = for {
instock = current.getOrElse(0)
taken = Math.min(instock,qty)
left = instock - taken
_ <- if (left > 0) fs.update(food,left) else fs.delete(food)
} yield taken

def cookSauce(qty: Quantity)(get: (FoodName,Quantity) => Future[Quantity],
put:(FoodName,Quantity) => Future[Unit]): Future[Quantity] = for {
tomato <- get("Tomato",qty)
veggie <- get("Veggie",qty)
garlic <- get("Garlic", qty * 3)
sauceQ = tomato / 2 + veggie * 3 / 2
_ <- put("Sauce",sauceQ)
} yield sauceQ

def cookMeals(qty: Quantity)(get: (FoodName,Quantity) => Future[Quantity],
put: (FoodName,Quantity) => Future[Unit]): Future[Quantity] =
for {
pasta <- get("Pasta", qty)
sauce <- get("Sauce", qty)
_ <- get("Spice",10)

meals = Math.min(pasta,sauce)
_ <- put("Meal", meals)

} yield meals```

```   implicit val refrigerator = new FoodStore

val shopping: Future[Unit] = for {
} yield ()

val cooking: Future[Quantity] = for {
_ <- shopping
} yield (meals)

val todaysMeals = Await.result(cooking,3 seconds)

println(s"we have \$todaysMeals pasta meals for the day.")```

0 条评论

• ### restapi（2）- generic restful CRUD：通用的restful风格数据库表维护工具

研究关于restapi的初衷是想搞一套通用的平台数据表维护http工具。前面谈过身份验证和使用权限、文件的上传下载，这次来到具体的数据库表维护。我们在这篇...

• ### restapi（0）- 平台数据维护，写在前面

在云计算的推动下，软件系统发展趋于平台化。云平台系统一般都是分布式的集群系统，采用大数据技术。在这方面akka提供了比较完整的开发技术支持。我在上一个系列...

• ### restapi（1）- 文件上传下载服务

上次对restapi开了个头，设计了一个包括了身份验证和使用权限的restful服务开发框架。这是一个通用框架，开发人员只要直接往里面加新功能就行了。虽然这次...

• ### Flutter异步编程

经常听说 future，或者从其他语言见到类似的说法如 javascript 的 Promise。那么究竟什么是 future？

• ### Flutter必备语言Dart教程04 - 异步，库

现在我们来看看如何在Dart中处理异步代码。使用Flutter时，会执行各种操作，例如网络调用和数据库访问，这些操作都应该异步执行。

• ### Dart中的异步操作

在前面的文章中我们很多次提到了Future这个东西，这个单词翻译过来的意思是‘未来’的意思。在flutter中它表示一个未来某些时候返回数据的一个对象。

• ### java中链表实现

package linklist; public class Node { public int iData; public double dData; ...

• ### # Event loop

​ dart是一种单线程语言，异步模型主要是通过事件轮询（event loop）来实现，另外也提供了更高级的Isolate来支持多线程，通常用于计算比较耗时的操...

• ### 零成本异步 I/O （下）

这个非常出色的基于轮询的新方案——我们编写了这个模型，我归功于 Alex 和 Aaron Turon，是他们提出了这个想法——不是由 Future 来调度回调函...

• ### 简单易学的机器学习算法——非线性支持向量机

一、回顾 image.png 二、非线性问题的处理方法     在处理非线性问题时，可以通过将分线性问题转化成线性问题，并通过已经构建的线性支持向量机来处理。如...