Scalaz（6）－ typeclass：Functor－just map
2024-08-25 04:50:44
Functor是范畴学（Category theory）里的概念。不过无须担心，我们在scala FP编程里并不需要先掌握范畴学知识的。在scalaz里，Functor就是一个普通的typeclass，具备map over特性。我的理解中，Functor的主要用途是在FP过程中更新包嵌在容器（高阶类）F[T]中元素T值。典型例子如：List[String], Option[Int]等。我们曾经介绍过FP与OOP的其中一项典型区别在于FP会尽量避免中间变量（temp variables）。FP的变量V是以F[V]这种形式存在的，如：List[Int]里一个Int变量是包嵌在容器List里的。所以FP需要特殊的方式来更新变量V，这就是Functor map over的意思。scalaz提供了Functor typeclass不但使用户能map over自定义的高阶类型F[T]，并且用户通过提供自定义类型的Functor实例就可以免费使用scalaz Functor typeclass提供的一系列组件函数（combinator functions）。
scalaz中Functor的trait是这样定义的：scalaz/Functor.scala
trait Functor[F[_]] extends InvariantFunctor[F] { self =>
////
import Liskov.<~<
/** Lift `f` into `F` and apply to `F[A]`. */
def map[A, B](fa: F[A])(f: A => B): F[B]
...
任何类型的实例只需要实现这个抽象函数map就可以使用scalaz Functor typeclass的这些注入方法了：scalaz/syntax/FunctorSyntax.scala
final class FunctorOps[F[_],A] private[syntax](val self: F[A])(implicit val F: Functor[F]) extends Ops[F[A]] {
////
import Leibniz.===
import Liskov.<~<
final def map[B](f: A => B): F[B] = F.map(self)(f)
final def distribute[G[_], B](f: A => G[B])(implicit D: Distributive[G]): G[F[B]] = D.distribute(self)(f)
final def cosequence[G[_], B](implicit ev: A === G[B], D: Distributive[G]): G[F[B]] = D.distribute(self)(ev(_))
final def cotraverse[G[_], B, C](f: F[B] => C)(implicit ev: A === G[B], D: Distributive[G]): G[C] = D.map(cosequence)(f)
final def ∘[B](f: A => B): F[B] = F.map(self)(f)
final def strengthL[B](b: B): F[(B, A)] = F.strengthL(b, self)
final def strengthR[B](b: B): F[(A, B)] = F.strengthR(self, b)
final def fpair: F[(A, A)] = F.fpair(self)
final def fproduct[B](f: A => B): F[(A, B)] = F.fproduct(self)(f)
final def void: F[Unit] = F.void(self)
final def fpoint[G[_]: Applicative]: F[G[A]] = F.map(self)(a => Applicative[G].point(a))
final def >|[B](b: => B): F[B] = F.map(self)(_ => b)
final def as[B](b: => B): F[B] = F.map(self)(_ => b)
final def widen[B](implicit ev: A <~< B): F[B] = F.widen(self)
////
}
以上的注入方法中除了map外其它方法的应用场景我还没有确切的想法，不过这不会妨碍我们示范它们的用法。Functor必须遵循一些定律：
1、map(fa)(x => x) === fa
2、map(map(fa)(f1))(f2) === map(fa)(f2 compose f1)
scalaz/Functor.scala
trait FunctorLaw extends InvariantFunctorLaw {
/** The identity function, lifted, is a no-op. map(fa)(x => x*/
def identity[A](fa: F[A])(implicit FA: Equal[F[A]]): Boolean = FA.equal(map(fa)(x => x), fa)
/**
* A series of maps may be freely rewritten as a single map on a
* composed function.
*/
def composite[A, B, C](fa: F[A], f1: A => B, f2: B => C)(implicit FC: Equal[F[C]]): Boolean = FC.equal(map(map(fa)(f1))(f2), map(fa)(f2 compose f1))
}
我们可以用List来证明：map(fa)(x => x) === fa
scala> List(,,).map(x => x) assert_=== List(,,) scala> List(,,).map(identity) assert_=== List(,)
java.lang.RuntimeException: [,,] ≠ [,]
at scala.sys.package$.error(package.scala:)
at scalaz.syntax.EqualOps.assert_$eq$eq$eq(EqualSyntax.scala:)
... elided
map(map(fa)(f1))(f2) === map(fa)(f2 compose f1)
scala> Functor[List].map(List(,,).map(i => i + ))(i2 => i2 * ) assert_=== List(,,).map(((i2:Int) => i2 * ) compose ((i:Int) => i + )) scala> Functor[List].map(List(,,).map(i => i + ))(i2 => i2 * ) assert_=== List(,,).map(((i:Int) => i + ) compose ((i2:Int) => i2 * ))
java.lang.RuntimeException: [,,] ≠ [,,]
at scala.sys.package$.error(package.scala:)
at scalaz.syntax.EqualOps.assert_$eq$eq$eq(EqualSyntax.scala:)
... elided
注意：compose对f1,f2的施用是互换的。
针对我们自定义的类型，我们只要实现map函数就可以得到这个类型的Functor实例。一旦实现了这个类型的Functor实例，我们就可以使用以上scalaz提供的所有Functor组件函数了。
我们先试着创建一个类型然后推算它的Functor实例：
case class Item3[A](i1: A, i2: A, i3: A)
val item3Functor = new Functor[Item3] {
def map[A,B](ia: Item3[A])(f: A => B): Item3[B] = Item3(f(ia.i1),f(ia.i2),f(ia.i3))
} //> item3Functor : scalaz.Functor[scalaz.functor.Item3] = scalaz.functor$$anonf
//| un$main$1$$anon$1@5e265ba4
scalaz同时在scalaz-tests下提供了一套scalacheck测试库。我们可以对Item3的Functor实例进行测试：
scala> functor.laws[Item3].check
<console>:: error: could not find implicit value for parameter af: org.scalacheck.Arbitrary[Item3[Int]]
functor.laws[Item3].check
^
看来我们需要提供自定义类型Item3的随意产生器（Generator）：
scala> implicit def item3Arbi[A](implicit a: Arbitrary[A]): Arbitrary[Item3[A]] = Arbitrary {
| def genItem3: Gen[Item3[A]] = for {
| b <- Arbitrary.arbitrary[A]
| c <- Arbitrary.arbitrary[A]
| d <- Arbitrary.arbitrary[A]
| } yield Item3(b,c,d)
| genItem3
| }
item3Arbi: [A](implicit a: org.scalacheck.Arbitrary[A])org.scalacheck.Arbitrary[Item3[A]]
scala> functor.laws[Item3].check
+ functor.invariantFunctor.identity: OK, passed tests.
+ functor.invariantFunctor.composite: OK, passed tests.
+ functor.identity: OK, passed tests.
+ functor.composite: OK, passed tests.
Item3的Functor实例是合理的。
实际上map就是(A => B) => (F[A] => F[B])，就是把(A => B)升格（lift）成（F[A] => F[B]）:
case class Item3[A](i1: A, i2: A, i3: A)
implicit val item3Functor = new Functor[Item3] {
def map[A,B](ia: Item3[A])(f: A => B): Item3[B] = Item3(f(ia.i1),f(ia.i2),f(ia.i3))
} //> item3Functor : scalaz.Functor[scalaz.functor.Item3] = scalaz.functor$$anonf
//| un$main$1$$anon$1@5e265ba4
val F = Functor[Item3] //> F : scalaz.Functor[scalaz.functor.Item3] = scalaz.functor$$anonfun$main$1$$
//| anon$1@5e265ba4
F.map(Item3("Morning","Noon","Night"))(_.length) //> res0: scalaz.functor.Item3[Int] = Item3(7,4,5)
F.apply(Item3("Morning","Noon","Night"))(_.length)//> res1: scalaz.functor.Item3[Int] = Item3(7,4,5)
F(Item3("Morning","Noon","Night"))(_.length) //> res2: scalaz.functor.Item3[Int] = Item3(7,4,5)
F.lift((s: String) => s.length)(Item3("Morning","Noon","Night"))
//> res3: scalaz.functor.Item3[Int] = Item3(7,4,5)
虽然函数升格（function lifting (A => B) => (F[A] => F[B])是Functor的主要功能，但我们说过：一旦能够获取Item3类型的Functor实例我们就能免费使用所有的注入方法：
scalaz提供了Function1的Functor实例。Function1 Functor的map就是 andThen 也就是操作方调换的compose：
scala> (((_: Int) + ) map((k: Int) => k * ))()
res20: Int = scala> (((_: Int) + ) map((_: Int) * ))()
res21: Int = scala> (((_: Int) + ) andThen ((_: Int) * ))()
res22: Int = scala> (((_: Int) * ) compose ((_: Int) + ))()
res23: Int =
我们也可以对Functor进行compose：
scala> val f = Functor[List] compose Functor[Item3]
f: scalaz.Functor[[α]List[Item3[α]]] = scalaz.Functor$$anon$@647ce8fd scala> val item3 = Item3("Morning","Noon","Night")
item3: Item3[String] = Item3(Morning,Noon,Night) scala> f.map(List(item3,item3))(_.length)
res25: List[Item3[Int]] = List(Item3(,,), Item3(,,))
反过来操作：
scala> val f1 = Functor[Item3] compose Functor[List]
f1: scalaz.Functor[[α]Item3[List[α]]] = scalaz.Functor$$anon$@5b6a0166 scala> f1.map(Item3(List(""),List(""),List("")))(_.length)
res26: Item3[List[Int]] = Item3(List(),List(),List())
我们再试着在Item3类型上调用那些免费的注入方法：
scala> item3.fpair
res28: Item3[(String, String)] = Item3((Morning,Morning),(Noon,Noon),(Night,Night)) scala> item3.strengthL()
res29: Item3[(Int, String)] = Item3((,Morning),(,Noon),(,Night)) scala> item3.strengthR()
res30: Item3[(String, Int)] = Item3((Morning,),(Noon,),(Night,)) scala> item3.fproduct(_.length)
res31: Item3[(String, Int)] = Item3((Morning,),(Noon,),(Night,)) scala> item3 as "Day"
res32: Item3[String] = Item3(Day,Day,Day) scala> item3 >| "Day"
res33: Item3[String] = Item3(Day,Day,Day) scala> item3.void
res34: Item3[Unit] = Item3((),(),())
我现在还没有想到这些函数的具体用处。不过从运算结果来看，用这些函数来产生一些数据模型用在游戏或者测试的模拟（simulation）倒是可能的。
scalaz提供了许多现成的Functor实例。我们先看看一些简单直接的实例：
scala> Functor[List].map(List(,,))(_ + )
res35: List[Int] = List(, , ) scala> Functor[Option].map(Some())(_ + )
res36: Option[Int] = Some() scala> Functor[java.util.concurrent.Callable]
res37: scalaz.Functor[java.util.concurrent.Callable] = scalaz.std.java.util.concurrent.CallableInstances$$anon$@4176ab89 scala> Functor[Stream]
res38: scalaz.Functor[Stream] = scalaz.std.StreamInstances$$anon$@4f5374b9 scala> Functor[Vector]
res39: scalaz.Functor[Vector] = scalaz.std.IndexedSeqSubInstances$$anon$@4367920a
对那些多个类型变量的类型我们可以采用部分施用方式：即type lambda来表示。一个典型的类型：Either[E,A]，我们可以把Left[E]固定下来: Either[String, A]，我们可以用type lambda来这样表述：
scala> Functor[({type l[x] = Either[String,x]})#l].map(Right())(_ + )
res41: scala.util.Either[String,Int] = Right()
如此这般我可以对Either类型进行map操作了。
函数类型的Functor是针对返回类型的：
scala> Functor[({type l[x] = String => x})#l].map((s: String) => s + "!")(_.length)("Hello")
res53: Int =
scala> Functor[({type l[x] = (String,Int) => x})#l].map((s: String, i: Int) => s.length + i)(_ * )("Hello",)
res54: Int =
scala> Functor[({type l[x] = (String,Int,Boolean) => x})#l].map((s: String,i: Int, b: Boolean)=> s + i.toString + b.toString)(_.toUpperCase)("Hello",,true)
res56: String = HELLO3TRUE
tuple类型的Functor是针对最后一个元素类型的：
cala> Functor[({type l[x] = (String,x)})#l].map(("a",))(_ + )
res57: (String, Int) = (a,)
scala> Functor[({type l[x] = (String,Int,x)})#l].map(("a",,"b"))(_.toUpperCase)
res58: (String, Int, String) = (a,,B)
scala> Functor[({type l[x] = (String,Int,Boolean,x)})#l].map(("a",,true,Item3("a","b","c")))(i => i.map(_.toUpperCase))
res62: (String, Int, Boolean, Item3[String]) = (a,,true,Item3(A,B,C))
最新文章
- C# 正则表达式总结
- 缓存插件 EHCache 页面缓存CachingFilter
- Upgrade Image&ntext to varbinarymax&nvarchar(max)
- iOS 进阶 第十六天(0419)
- Linux下SCP的使用
- 新手学习数据库（一）用Powerdesigner设计数据库
- CentOS 修改默认语言
- 基于visual Studio2013解决C语言竞赛题之1093连接链表
- Merging a WPF application into a single EXE(WPF应用程序合并成单个Exe文件)
- JSP直接调用一个action定向到页面
- Cocos2d-x 多分辨率支持
- shell编程基础(五): 正则表达式及其使用
- Android 底部导航栏实现一 Fragment-replace
- 【转】java将excel文件转换成txt格式文件
- vue router 根据不同的id切换链接界面不刷新
- python常用函数总结
- Linux 命令详解（十）Shell脚本的数组详解
- Go 灵活多变的切片Slice
- ActiveMQ 事务和XA
- 如何在Windows下安装Tomcat服务器