Scalaz(14)- Monad:函数组合-Kleisli to Reader

  Monad Reader就是一种函数的组合。在scalaz里函数(function)本身就是Monad,自然也就是Functor和applicative。我们可以用Monadic方法进行函数组合:

 1 import scalaz._
 2 import Scalaz._
 3 object decompose {
 4 //两个测试函数
 5 val f = (_: Int) + 3                              //> f  : Int => Int = <function1>
 6 val g = (_: Int) * 5                              //> g  : Int => Int = <function1>
 7 //functor
 8 val h = f map g  // f andThen g                   //> h  : Int => Int = <function1>
 9 val h1 = g map f  // f compose g                  //> h1  : Int => Int = <function1>
10 h(2)  //g(f(2))                                   //> res0: Int = 25
11 h1(2) //f(g(2))                                   //> res1: Int = 13
12 //applicative
13 val k = (f |@| g){_ + _}                          //> k  : Int => Int = <function1>
14 k(10) // f(10)+g(10)                              //> res2: Int = 63
15 //monad
16 val m = g.flatMap{a => f.map(b => a+b)}           //> m  : Int => Int = <function1>
17 val n = for {
18   a <- f
19   b <- g
20 } yield a + b                                     //> n  : Int => Int = <function1>
21 m(10)                                             //> res3: Int = 63
22 n(10)                                             //> res4: Int = 63
23 }

以上的函数f,g必须满足一定的条件才能实现组合。这个从f(g(2))或g(f(2))可以看出:必需固定有一个输入参数及输入参数类型和函数结果类型必需一致,因为一个函数的输出成为另一个函数的输入。在FP里这样的函数组合就是Monadic Reader。 

但是FP里函数运算结果一般都是M[R]这样格式的,所以我们需要对f:A => M[B],g:B => M[C]这样的函数进行组合。这就是scalaz里的Kleisli了。Kleisli就是函数A=>M[B]的类封套,从Kleisli的类定义可以看出:scalaz/Kleisli.scala

1 final case class Kleisli[M[_], A, B](run: A => M[B]) { self =>
2 ...
3 trait KleisliFunctions {
4   /**Construct a Kleisli from a Function1 */
5   def kleisli[M[_], A, B](f: A => M[B]): Kleisli[M, A, B] = Kleisli(f)
6 ...

Kleisli的目的是把Monadic函数组合起来或者更形象说连接起来。Kleisli提供的操作方法如>=>可以这样理解:

(A=>M[B]) >=> (B=>M[C]) >=> (C=>M[D]) 最终运算结果M[D]

可以看出Kleisli函数组合有着固定的模式:

1、函数必需是 A => M[B]这种模式;只有一个输入,结果是一个Monad M[_]

2、上一个函数输出M[B],他的运算值B就是下一个函数的输入。这就要求下一个函数的输入参数类型必需是B

3、M必须是个Monad;这个可以从Kleisli的操作函数实现中看出:scalaz/Kleisli.scala

 1   /** alias for `andThen` */
 2   def >=>[C](k: Kleisli[M, B, C])(implicit b: Bind[M]): Kleisli[M, A, C] =  kleisli((a: A) => b.bind(this(a))(k.run))
 3 
 4   def andThen[C](k: Kleisli[M, B, C])(implicit b: Bind[M]): Kleisli[M, A, C] = this >=> k
 5 
 6   def >==>[C](k: B => M[C])(implicit b: Bind[M]): Kleisli[M, A, C] = this >=> kleisli(k)
 7 
 8   def andThenK[C](k: B => M[C])(implicit b: Bind[M]): Kleisli[M, A, C] = this >==> k
 9 
10   /** alias for `compose` */
11   def <=<[C](k: Kleisli[M, C, A])(implicit b: Bind[M]): Kleisli[M, C, B] = k >=> this
12 
13   def compose[C](k: Kleisli[M, C, A])(implicit b: Bind[M]): Kleisli[M, C, B] = k >=> this
14 
15   def <==<[C](k: C => M[A])(implicit b: Bind[M]): Kleisli[M, C, B] = kleisli(k) >=> this
16 
17   def composeK[C](k: C => M[A])(implicit b: Bind[M]): Kleisli[M, C, B] = this <==< k

拿操作函数>=>(andThen)举例:implicit b: Bind[M]明确了M必须是个Monad。

kleisli((a: A) => b.bind(this(a))(k.run))的意思是先运算M[A],接着再运算k,以M[A]运算结果值a作为下一个函数k.run的输入参数。整个实现过程并不复杂。

实际上Reader就是Kleisli的一个特殊案例:在这里kleisli的M[]变成了Id[],因为Id[A]=A >>> A=>Id[B] = A=>B,就是我们上面提到的Reader,我们看看Reader在scalaz里是如何定义的:scalar/package.scala

 1   type ReaderT[F[_], E, A] = Kleisli[F, E, A]
 2   val ReaderT = Kleisli
 3   type =?>[E, A] = Kleisli[Option, E, A]
 4   type Reader[E, A] = ReaderT[Id, E, A]
 5 
 6   type Writer[W, A] = WriterT[Id, W, A]
 7   type Unwriter[W, A] = UnwriterT[Id, W, A]
 8 
 9   object Reader {
10     def apply[E, A](f: E => A): Reader[E, A] = Kleisli[Id, E, A](f)
11   }
12 
13   object Writer {
14     def apply[W, A](w: W, a: A): WriterT[Id, W, A] = WriterT[Id, W, A]((w, a))
15   }
16 
17   object Unwriter {
18     def apply[U, A](u: U, a: A): UnwriterT[Id, U, A] = UnwriterT[Id, U, A]((u, a))
19   }

type ReaderT[F[_], E, A] = Kleisli[F, E, A] >>> type Reader[E,A] = ReaderT[Id,E,A]

好了,说了半天还是回到如何使用Kleisli进行函数组合的吧:

 1 //Kleisli款式函数kf,kg
 2 val kf: Int => Option[String] = (i: Int) => Some((i + 3).shows)
 3                                                   //> kf  : Int => Option[String] = <function1>
 4 val kg: String => Option[Boolean] = { case "3" => true.some; case _ => false.some }
 5                                                   //> kg  : String => Option[Boolean] = <function1>
 6 //Kleisli函数组合操作
 7 import Kleisli._
 8 val kfg = kleisli(kf) >=> kleisli(kg)             //> kfg  : scalaz.Kleisli[Option,Int,Boolean] = Kleisli(<function1>)
 9 kfg(1)                                            //> res5: Option[Boolean] = Some(false)
10 kfg(0)                                            //> res6: Option[Boolean] = Some(true)

例子虽然很简单,但它说明了很多重点:上一个函数输入的运算值是下一个函数的输入值 Int=>String=>Boolean。输出Monad一致统一,都是Option。

那么,Kleisli到底用来干什么呢?它恰恰显示了FP函数组合的真正意义:把功能尽量细分化,通过各种方式的函数组合实现灵活的函数重复利用。也就是在FP领域里,我们用Kleisli来组合FP函数。

下面我们就用scalaz自带的例子scalaz.example里的KleisliUsage.scala来说明一下Kleisli的具体使用方法吧:

下面是一组地理信息结构:

1   // just some trivial data structure ,
2   // Continents contain countries. Countries contain cities.
3   case class Continent(name: String, countries: List[Country] = List.empty)
4   case class Country(name: String, cities: List[City] = List.empty)
5   case class City(name: String, isCapital: Boolean = false, inhabitants: Int = 20)

分别是:洲(Continent)、国家(Country)、城市(City)。它们之间的关系是层级的:Continent(Country(City))

下面是一组模拟数据:

 1  val data: List[Continent] = List(
 2     Continent("Europe"),
 3     Continent("America",
 4       List(
 5         Country("USA",
 6           List(
 7             City("Washington"), City("New York"))))),
 8     Continent("Asia",
 9       List(
10         Country("India",
11           List(City("New Dehli"), City("Calcutta"))))))

从上面的模拟数据也可以看出Continent,Country,City之间的隶属关系。我们下面设计三个函数分别对Continent,Country,City进行查找:

 1   def continents(name: String): List[Continent] =
 2     data.filter(k => k.name.contains(name))       //> continents: (name: String)List[Exercises.kli.Continent]
 3   //查找名字包含A的continent
 4   continents("A")                                 //> res7: List[Exercises.kli.Continent] = List(Continent(America,List(Country(U
 5                                                   //| SA,List(City(Washington,false,20), City(New York,false,20))))), Continent(A
 6                                                   //| sia,List(Country(India,List(City(New Dehli,false,20), City(Calcutta,false,2
 7                                                   //| 0))))))
 8   //找到两个:List(America,Asia)
 9   def countries(continent: Continent): List[Country] = continent.countries
10                                                   //> countries: (continent: Exercises.kli.Continent)List[Exercises.kli.Country]
11   //查找America下的国家
12   val america =
13       Continent("America",
14       List(
15         Country("USA",
16           List(
17             City("Washington"), City("New York")))))
18                                                   //> america  : Exercises.kli.Continent = Continent(America,List(Country(USA,Lis
19                                                   //| t(City(Washington,false,20), City(New York,false,20)))))
20   countries(america)                              //> res8: List[Exercises.kli.Country] = List(Country(USA,List(City(Washington,f
21                                                   //| alse,20), City(New York,false,20))))
22   def cities(country: Country): List[City] = country.cities
23                                                   //> cities: (country: Exercises.kli.Country)List[Exercises.kli.City]
24   val usa = Country("USA",
25             List(
26               City("Washington"), City("New York")))
27                                                   //> usa  : Exercises.kli.Country = Country(USA,List(City(Washington,false,20), 
28                                                   //| City(New York,false,20)))
29   cities(usa)                                     //> res9: List[Exercises.kli.City] = List(City(Washington,false,20), City(New Y
30                                                   //| ork,false,20))

从continents,countries,cities这三个函数运算结果可以看出它们都可以独立运算。这三个函数的款式如下:

String => List[Continent]

Continent => List[Country]

Country => List[City]

无论函数款式或者类封套(List本来就是Monad)都适合Kleisli。我们可以用Kleisli把这三个局部函数用各种方法组合起来实现更广泛功能:

 1   val allCountry = kleisli(continents) >==> countries
 2                                                   //> allCountry  : scalaz.Kleisli[List,String,Exercises.kli.Country] = Kleisli(<
 3                                                   //| function1>)
 4   val allCity = kleisli(continents) >==> countries >==> cities
 5                                                   //> allCity  : scalaz.Kleisli[List,String,Exercises.kli.City] = Kleisli(<functi
 6                                                   //| on1>)
 7   allCountry("Amer")                              //> res10: List[Exercises.kli.Country] = List(Country(USA,List(City(Washington,
 8                                                   //| false,20), City(New York,false,20))))
 9   allCity("Amer")                                 //> res11: List[Exercises.kli.City] = List(City(Washington,false,20), City(New 
10                                                   //| York,false,20))

还有个=<<符号挺有意思:

1   def =<<(a: M[A])(implicit m: Bind[M]): M[B] = m.bind(a)(run)

意思是用包嵌的函数flatMap一下输入参数M[A]:

1   allCity =<< List("Amer","Asia")                 //> res12: List[Exercises.kli.City] = List(City(Washington,false,20), City(New 
2                                                   //| York,false,20), City(New Dehli,false,20), City(Calcutta,false,20))

那么如果我想避免使用List(),用Option[List]作为函数输出可以吗?Option是个Monad,第一步可以通过。下一步是把函数款式对齐了:

List[String] => Option[List[Continent]]

List[Continent] => Option[List[Country]]

List[Country] => Option[List[City]]

下面是这三个函数的升级版:

 1   //查找Continent List[String] => Option[List[Continent]]
 2   def maybeContinents(names: List[String]): Option[List[Continent]] =
 3     names.flatMap(name => data.filter(k => k.name.contains(name))) match {
 4        case h :: t => (h :: t).some
 5        case _ => none
 6     }                                             //> maybeContinents: (names: List[String])Option[List[Exercises.kli.Continent]]
 7                                                   //| 
 8   //测试运行
 9   maybeContinents(List("Amer","Asia"))            //> res13: Option[List[Exercises.kli.Continent]] = Some(List(Continent(America,
10                                                   //| List(Country(USA,List(City(Washington,false,20), City(New York,false,20))))
11                                                   //| ), Continent(Asia,List(Country(India,List(City(New Dehli,false,20), City(Ca
12                                                   //| lcutta,false,20)))))))
13   //查找Country  List[Continent] => Option[List[Country]]
14   def maybeCountries(continents: List[Continent]): Option[List[Country]] =
15     continents.flatMap(continent => continent.countries.map(c => c)) match {
16        case h :: t => (h :: t).some
17        case _ => none
18     }                                             //> maybeCountries: (continents: List[Exercises.kli.Continent])Option[List[Exer
19                                                   //| cises.kli.Country]]
20    //查找City  List[Country] => Option[List[Country]]
21   def maybeCities(countries: List[Country]): Option[List[City]] =
22     countries.flatMap(country => country.cities.map(c => c)) match {
23        case h :: t => (h :: t).some
24        case _ => none
25     }                                             //> maybeCities: (countries: List[Exercises.kli.Country])Option[List[Exercises.
26                                                   //| kli.City]]
27   
28   val maybeAllCities = kleisli(maybeContinents) >==> maybeCountries >==> maybeCities
29                                                   //> maybeAllCities  : scalaz.Kleisli[Option,List[String],List[Exercises.kli.Cit
30                                                   //| y]] = Kleisli(<function1>)
31   maybeAllCities(List("Amer","Asia"))             //> res14: Option[List[Exercises.kli.City]] = Some(List(City(Washington,false,2
32                                                   //| 0), City(New York,false,20), City(New Dehli,false,20), City(Calcutta,false,
33                                                   //| 20)))

我们看到,只要Monad一致,函数输入输出类型匹配,就能用Kleisli来实现函数组合。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏技术栈大杂烩

Python源码理解: '+=' 和 'xx = xx + xx'的区别

为什么上面不同的对象执行同一个+会有不同的效果呢? 这就涉及到+的重载, 然而这不是本文要讨论的重点, 上面的只是前菜而已~~~

411
来自专栏社区的朋友们

Unity GC 优化 贴士大全

Unity中频繁的垃圾回收往往是造成手游性能瓶颈的一大元凶,本文对常见的造成频繁垃圾回收的原因做一个扫描,让开发者在日常开发中可以有意识的避开这些问题。

2410
来自专栏一个会写诗的程序员的博客

使用 Kotlin 实现 Y 组合子(Y-Combinator)使用 Kotlin 实现 Y 组合子(Y-Combinator)《Kotlin极简教程》正式上架:

我们可以使用 Kotlin FP (Lambda, function) 写一个 Y-combinator 函数吗?

432
来自专栏后端之路

mybatis 任意查询传入默认动态参数

import org.apache.ibatis.builder.xml.dynamic.DynamicContext; import org.apache.i...

4118
来自专栏码匠的流水账

聊聊flink LocalEnvironment的execute方法

flink-java-1.6.2-sources.jar!/org/apache/flink/api/java/DataSet.java

573
来自专栏码匠的流水账

聊聊hystrix的timeout处理

hystrix-core-1.5.12-sources.jar!/com/netflix/hystrix/AbstractCommand.java

852
来自专栏高性能服务器开发

(三)dict哈希结构3

/* This function performs just a step of rehashing, and only if there are * no...

2628
来自专栏用户2442861的专栏

FastJson的使用

FastJson 的Wiki在这里:https://github.com/alibaba/fastjson/wiki/

441
来自专栏码匠的流水账

聊聊flink的ParallelIteratorInputFormat

本文主要研究一下flink的ParallelIteratorInputFormat

553
来自专栏函数式编程语言及工具

深圳scala-meetup-20180902(3)- Using heterogeneous Monads in for-comprehension with Monad Transformer

  scala中的Option类型是个很好用的数据结构,用None来替代java的null可以大大降低代码的复杂性,它还是一个更容易解释的状态表达形式,比如在读...

552

扫码关注云+社区