真的学不动了: 除了 class , 也该了解 Type classes 了

作为一个 Java 开发者class 的概念肯定是耳熟能详了,可是在山的另一边还有拥有别样风情的 type classes ,但不翻过 Java 这座山,它就始终隔着一层纱。

一个经典的问题

在编程中,经常需要判断两个值是否相等,而在很长的一段时间内这个问题都没有一个标准的解决方案,这就是经典的 判等 问题。

我这里统一使用 “值” 来代替对象、基本类型等等概念,以便于简化沟通

在 Java 中,我们可以用 == ,也可以用 equals 来判断值是否相等

public void test() {
    boolean res = "hello" == "world";
  
    boolean res2 = "hello".equals("hello");

    boolean res3 = 3 == 3;

    boolean res4 = 5 == 9;
}
复制代码

熟悉 Java 的同学都知道对于非基础类型, == 操作实际比较的是对象的 hashCode,而 equals 方法的默认实现其实就是调用的 == 操作符

public class Object {
  // ......
  
  public boolean equals(Object obj) {
  	return (this == obj);
  }
  
  // ......
}
复制代码

所有类都会有 equals 方法,这是因为在 Java 中默认所有类型都是 Object 的子类,而 equals 方法的默认实现就被定义在了 Object 类中。

其实这也是 Java 语言处理 判等问题 的解决方案,即统一从 Object 中继承判等方法。

真的学不动了: 除了 class , 也该了解 Type classes 了

可是对于纯函数式的语言,比如 Haskell 来说,它没有 OOP 中的继承、类等概念,它又该如何优雅的解决判等的问题呢?

如果你觉得 Haskell 比较陌生,我们就换一种提问的方式: 还有其它通用的设计方案可以解决这类判等问题吗

当然有,而 Type classes 就是这个领域内最靓的那个仔,要了解 Type classes, 还得先从多态开始。

Type classes 与多态

Type classes 结合了 ad-hoc polymorphism(特设多态)和 Parametric polymorphism (参数化多态),实现了一种更通用的重载。

问题来了,什么是特设多态、参数化多态呢?

关于多态的更多内容 ,还可以参考我的前一篇文章《多态都不知道,谈什么对象》

  • ad-hoc polymorphism (特设多态) 指的是函数应用不同类型的参数时,会有不同的行为(或者说实现)

    最典型的就是算术重载

    3 * 3  // 代表两个整形的乘法
    
    3.14 * 3.14 // 代表两个浮点数的乘法
    复制代码
  • Parametric polymorphism (参数化多态) 指的是函数被定义在 某一些类型 之上,对于这些类型来说函数的实现都是一样的。

    比如 List[T] 的 size() 函数,无论 T 的类型是 String、还是 Int, size() 的实现都一样

    List[String].size()
    List[Int].size()
    复制代码

虽然 Type classes 结合了两种多态类型,但它本身却被归到特设多态(ad-hoc polymorphism)这一分类下。

如果你想了解更多 type classes 的思想,非常推荐阅读 《How to make ad-hoc polymorphism less ad hoc》 这篇论文,它也算是 Type classes 的开篇作。

Haskell 与 Type classes

Type classes 一般译作类型类,最开始是由 haskell 引入并实现,所以我们很有必要先了解一下 haskell 中的 Type classes。

以最开始提到的判等问题为例,来看看在 Haskell 中怎么用 Type classes 去解决。

首先我们得用关键字 class 定义一个 Type class,千万不要和 Java 的 class 混为一谈。

class Eq a where
	(==) :: a -> a -> Bool
	(/=) :: a -> a -> Bool
复制代码

/= 其实就是 !=

haskell 的 Type class 与 Java 的 Interface 类似,上面的 Eq 类型类就定义了 ==/= 两个抽象函数,其中的 a 就是类型变量,与 Java 中的泛型类似。

由此看来,Type classes 只是抽象了一些共同的行为,而这些行为的具体实现会根据类型的不同而不同,具体的实现会由 类型类实例 来定义。

通过 instance 关键字可以创建类型类实例,下面展示了针对于于 Float 和 Int 的 Eq 类型类实例

instance Eq Int where
	(==) = eqInt
	(/=) = neInt
	
instance Eq Float where
	(==) = eqFloat
	(/=) = neFloat

复制代码

我们假设 eqInt、neInt、eqFloat、neFloat 都已经由标准库实现了

这样就可以直接用 ==/= 函数对 Int 和 Float 进行判等了

-- 判断 Int 的相等性
== 1 2
/= 2 4

-- 判断 Float 的相等性
== 1.2 1.2
/= 2.4 2.1
复制代码

在调用 ==/= 函数时,编译器会根据参数类型自动找到类型类实例,然后调用类型类实例的函数执行调用。

如果用户需要自定义判等函数,只需要实现自己的类型类实例即可。

此时你可能会不自觉的和最开始提到的继承方案做一个对比,我画了两个图,可以参考一下

  • 继承方案的类型结构是一个层次型的
真的学不动了: 除了 class , 也该了解 Type classes 了
  • Type classes 方案的类型结构是线性的
真的学不动了: 除了 class , 也该了解 Type classes 了

如果仅仅从结构上来看的话,它们之间的差别就像 ComparableComparator 一样。

Scala 与 Type classes Pattern

目前的 Java 是无法实现 Type classes 的,但同为 JVM 的语言,多范式的 Scala 却可以实现。

与 Haskell 不一样, Type classes 在 Scala 中并不是一等公民,也就是没有直接的语法支持,但借助于强大的 隐式系统 我们也能实现 Type classes,由于实现的步骤比较公式化,也就被称之为 Type classes Pattern (类型类模式)。

在 Scala 中实现 Type classes Pattern 大致分为 3 个步骤

  1. 定义 Type class
  2. 实现 Type class 实例
  3. 定义包含 隐式参数 的函数

还是以前面提到的判等问题为需求,按照前面总结的模式步骤来实现一个 Scala 版的 Type classes 解决方案。

第一步定义 Type class,实际就是定义一个带泛型参数的 trait

trait 也类似于 Java 的 interface,不过更加强大

trait Eq[T] {
  def eq(a: T, b: T): Boolean
}
复制代码

接着我们针对 String、Int 来实现两个类型类实例

object EqInstances {

  implicit val intEq = new Eq[Int] {
    override def eq(a: Int, b: Int) = a == b
  }

  implicit val stringEq = instance[String]((a, b) => a.equals(b))

  def instance[T](func: (T, T) => Boolean): Eq[T] = new Eq[T] {
    override def eq(a: T, b: T): Boolean = func(a, b)
  }
}
复制代码

stringEq 和 intEq 采用了不同的构造方式

  • stringEq 实例我采用的是类似于 Java 的匿名类进行构造
  • intEq 实例则采用了高阶函数来实现

两个实例都被 implicit 关键字修饰,一般称之为 隐式值 ,作用会在后面讲到。

最后一步,来实现一个带隐式参数的 same 函数, 其实调用类型类实例来判断两个值是否相等

object Same {
  def same[T](a: T, b: T)(implicit eq: Eq[T]): Boolean = eq.eq(a, b)
}

复制代码
  • implicit eq: Eq[T] 就是隐式参数, 调用方可以不用主动传入,编译器会在作用域内查找匹配的隐式值传入 (这就是为什么前面的实例需要被 implicit 修饰)

最后来进行调用验证一下,在调用时我们需要先在当前作用域内通过 import 关键字导入 类型类实例 (主要是为了让编译器能找到这些实例)

import EqInstances._

Same.same(1, 2)

Same.same("ok", "ok")

// 编译错误:no implicits found for parameter eq: Eq[Float]
Same.same(1.0F, 2.4F)
复制代码

可以看见,针对 Int 和 String 类型的 same 函数调用能通过编译, 而当参数是 Float 时调用就会提示编译错误,这就是因为编译器在作用域内没有找到可以处理 Float 类型的 Eq 实例。

关于 Scala 隐式查找的更多规则可以查看 docs.scala-lang.org/tutorials/F…

到这儿其实就差不多了,但是这样的写法在 Scala 里其实不是很优雅,我们可以再通过一些小技巧优化一下

  • same 函数改为 apply 函数,可以简化调用

  • 使用 context bound 优化隐式参数,别慌,context bound 实际就是个语法糖而已

object Same {
  def apply[T: Eq](a: T, b: T): Boolean = implicitly[Eq[T]].eq(a, b)
}

// 使用 apply 作为函数, 调用时可以不用写函数名
Same(1, 1)
Same("hello", "world")
复制代码

简单说一下 context bund,首先泛型的定义 由 T 变成了 [T: Eq] ,这样就可以用 implicitly [Eq[T]] 让编译器在作用域内找到一个 Eq[T] 的隐式实例,context bound 可以让函数的签名更加简洁。

在 Scala 中,类型类的设计其实随处可见,典型的就有 Ordered

回望 Java

以判等问题引出 Type classes 有一些不足,我们只意识到了与 OOP 的继承是一个不一样的判等解决方案,不妨再回到 Java 做一些其他的比较。

Comparator[T] 接口为例,在 Java 中我们经常在集合框架中这样使用

List<Integer> list = new ArrayList<>();
list.sort(Comparator.naturalOrder())
复制代码

如果将其改造成为 Type classes 的话

trait Comparator[T] {
  def compare(o1: T, o2: T): Int
}

object Instances { 
  // ...
}
复制代码

List 的 sort 方法也需要改为带隐式参数的方法前面,这样我们就不需要显示的传 Compartor 实例了

// 编译期会自动找到 Comparator[Integer] 实例
List[Integer] list = new ArrayList<>();
list.sort()
复制代码

上面的 Type classes 是基于 Scala 语法的伪代码

相信你也看出来了,与 Type classes 方案相比,最大的差别就是 Java 需要手动传入 Comparator 实例,也许你会疑惑:就这?

不要小看这两者的区别,这两者的区别就像用 var 定义类型一样

// Java8
Map<String, String> map2 = new HashMap<>();

// Java10
var map = new HashMap<String, String>();
复制代码

如果类型系统能帮你完成的事情,就让它帮你做吧!

总结一下

看了 Haskell 和 Scala 的例子,最后还是得总结一下:

Type classes 就是抽象了某一些类型的共同行为,当某个类型需要用到这些行为时,由类型系统去找到这些行为的具体实现。

未完待续

最后还是得再安利一下 Scala3,在 Scala3 中, Type classes 得到了足够的重视,直接提供了语法层面的支持,再也不用写一大堆的模板代码, 从此可以叫做 Type classes without Pattern

不过为了避免“长篇大论”,相关的内容就留给下一篇文章了(点赞点赞点赞)。

弱弱的皮一下,还学得动吗?

原文 

https://juejin.im/post/5f0fd5fe5188252e5f37d7fc

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 真的学不动了: 除了 class , 也该了解 Type classes 了

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址