小本本记下来！带你一起探秘 Scala3 与 Type classes

最新推荐文章于 2022-03-20 15:59:04 发布
最新推荐文章于 2022-03-20 15:59:04 发布
阅读量286 收藏 1
点赞数
文章标签： 编译器 proxy makefile bug 编程语言

作者 | vran

Hello, 麻烦给我的代码来一杯 Mojito

引言

Type classes 源自 Haskell，在 Scala 中并没有直接的语法和概念，但却可以借助于强大的隐式系统间接实现，一般称之为 Type classes Pattern。

Type classes pattern 可谓是 Scala 中的屠龙技之一，然而这一招式随着 Scala3 的发布也产生了巨大的变化......

关于 Type classes 更多内容，可以参考 《怒了！TypeClass什么时候变得这么重要了？》。

回顾 Scala2 与 Type classes

Scala2 中 Type classes Pattern 有个固定的套路

  1. 基于 trait 和泛型定义 Type class

  2. 实现 Type class 实例

  3. 定义包含隐式参数的函数

下面用 Scala2 中的 Type classes Pattern 来改造一下经典的  Comparator 接口，相比于上一篇文章，这里的实现会多一些细节。

trait Comparator[T] {
  def compare(a: T, b: T): Int
}

object ComparatorInstances {
  implicit val intComparator = new Comparator[Int] {
    override def compare(a: Int, b: Int) = a.compareTo(b)
  }
  
  implicit def listComparator[T](implicit cmp: Comparator[T]) = new Comparator[List[T]] {
    override def compare(a: List[T], b: List[T]): Int = {
      (a, b) match {
        // 连个都为空
        case (Nil, Nil) => 0
        // 某一个为空
        case (Nil, _) => 1
        case (_, Nil) => -1
        // 两个都不为空，
        case (l, r) =>
        	// 比较头结点
          cmp.compare(l.head, r.head) match {
            // List.tail 表示除了头结点以外的结点
            case 0 => compare(l.tail, r.tail)
            case num => num
          }
      }
    }
  }
}

object Same {
  def apply[T](a: T, b: T)(implicit cmp: Comparator[T]) = cmp.compare(a, b) == 0
}

稍微要说一下的就是  listComparator 这个函数了，这种用 implicit def 定义的方法一般称之为「隐式转换方法」。

隐式转换方法就是由编译器把参数的类型转换为返回值的类型（不需要显示的调用该方法）。

而  listComparator 函数的作用就是当你需要 Comparator[List[T]] 的实例时，编译器会在作用域内找到 Comparator[T] 的实例，然后将其转换为 Comparator[List[T]] 的实例。

如果没有这个方法

  • 处理 List[Int] 时需要定义一个 Comparator[List[Int]] 类型类实例

  • 处理 List[String] 时需要定义一个 Comparator[List[String]] 类型类实例

  • ......

有了该隐式方法以后

  • 处理 List[Int] 时，编译器会找到 Comparator[Int] 的实例， 然后根据该方法得到 Comparator[List[Int]] 实例进行处理

  • 处理 List[String] 时， 编译器会找到 Comparator[String] 的实例， 然后根据该方法得到 Comparator[List[String]] 实例进行处理

  • ......

其实最主要的作用就是在处理高阶类型时能复用已有的 Type class 实例。

最后再来测试一下， 调用前需要先将 Type class 实例都导入（正常的 import 语法）到作用域内

import ComparatorInstances._
Same(1, 2)
Same(List(1, 2), List(1, 2))

在 Scala 中实现 type classes，很多时候还会使用函数扩展来简化调用，Scala 中的函数扩展是基于隐式类来实现的。

比如下面的代码就是在不修改 T 类型的情况下为 其扩展了 < 、 > 和 isSameTo 三个个函数

object ComparatorInstances {
  // ...

  implicit class Ops[T](a: T)(implicit cmp: Comparator[T]) {
    
    def isSameTo(b: T) = cmp.compare(a, b) == 0
    
    def <(b: T) = cmp.compare(a, b) < 0

    def >(b: T) = cmp.compare(a, b) > 0
  }

}

结合 Type classes Pattern 和函数扩展，使得调用更加自然（中缀式表示）

import ComparatorInstances._
Same(List(1, 2), List(1, 2))
// 函数扩展为 List 扩展了 < 函数
List(1,2).<(List(1, 3))
// 也可以省略 . 和参数括号
List(1, 2) < List(1, 3)
// 函数扩展
List(1,2).isSameTo(List(2, 3))
List(1, 2) isSameTo List(2, 3)

虽然借助于隐式系统实现了 Type classes, 但还是有刺可以挑的

  • 语言层面的支持不友好

    引入了晦涩的隐式转换等概念，而这也是导致 Scala 的 Type classes 难以掌握的原因之一。

    难道就不能有更友好的语法支持吗？

  • 实例导入冲突

    我明明只是导入了某些依赖，但这个依赖里面却有 type class 实例，它覆盖了我期望调用的实例，造成了非常隐秘的 BUG。

    （从另一个角度来说，这个实例可覆盖又是一个灵活性的体现）

    难道就不能区分普通的 import 和 type class 实例的 import 吗？

对于使用隐式系统实现 Type classes 的缺点，还可以参考文末参考文档 2《The Limitations of Type Classes as Subtyped Implicits》

探秘 Scala3 与 Type classes

在 Scala 2 中，隐式系统是造成 Type classes Pattern 难以掌握的原因之一。

而在 Scala3 中，将再也不用为 纠结 implicit 该怎么用了， 它被全新的 Given、Using、Extension Method 等特性所替代。

要使用 Scala3 的语法的话，需要到 https://dotty.epfl.ch/ 下载 Dotty 编译器

Talk is Cheap，我们用 Scala3 的语法再次改造一遍 Comparator 。

Given 与 Type class 实例

首先是 Type class 的定义，这一块和以前没有区别，还是基于 trait 和泛型。

trait Comparator[T] {
  def compare[T](a: T, b: T): Int
}

然后就是实现 Type class 实例了，用全新的语法 given...as 来实现。

given intCompare as Comparator[Int] {
  override def compare(a: Int, b: Int) = a.compareTo(b)
}

given 后面跟实例名称， as 可以指定类型，实际体验和「匿名类」的构造很相似。

given 支持命名构造和匿名构造，当使用匿名构造时编译器会为实例自动生成一个可读的名称，下面展示了具体的代码：

object ComparatorInstances {

  // 命名构造
  given intComparator as  Comparator[Int] {
    override def compare(a: Int, b: Int) = a.compareTo(b)
  }
  
  // 匿名构造 自动生成可读的实例名称： given_Comparator_String
  given Comparator[String] {
    override def compare(a: String, b: String) = a.compareTo(b) 
  }

  // 高阶函数命名构造
  given doubleComparator as Comparator[Double] = instance[Double]((a, b) => a.compareTo(b))
  
  // 高阶函数匿名构造
  given Comparator[Float] = instance[Float]((a, b) => a.compareTo(b))
  
  private def instance[T](func: (T, T) => Int) = new Comparator[T] {
    override def compare(a: T, b: T) = func(a, b)
  }
}

Using 与 Given

前面通过 given 实现了类型类实例，可是什么时候使用这些实例呢？

这就轮到好基友 using 出场 了， using 用于修饰参数。

被 using 修饰的参数称之为上下文参数，该参数可以不用手动传入，编译器会在作用域内寻找匹配的 given 实例传入（类似于 Scala2 的隐式参数）。

object Same {
  // 命名上下文参数
  def apply[T](a: T, b: T)(using cmp: Comparator[T]) = cmp.compare(a, b) == 0
}

Given Import

前面提到『编译器会在作用域自动寻找匹配的 given 实例』，在 Scala2 以前主要是通过 Import 导入，也就是 import ComparatorInstances._ 。

在 Scala3 中即使这样导入了，编译仍然报错：提示找不到对应的实例。

这是因为针对 given 实例的导入也有了单独的语法，特意用于区分普通的依赖导入。

Scala3 中，given 实例的导入称之为 `given import， 它的语法也很简单

// 导入单个实例
import xxx.{given aInstance}
// 通配符 导入所有实例
import xxx.{given _}

通过 ComparatorInstances 验证一下

// 导入所有 given 实例就用占位符 _
// 也可以只导入某一个实例
import ComparatorInstances.{given _}

Same(1, 2)
Same(1.2F, 2.2F)
Same(1.2D, 2.2D)
Same("ok", "ok")

这样，一个 Scala3 版的 Type classes Pattern 就完成了，一个 implicit 也看不见了。

相较于 Scala2 版，并没有减少多少代码量，但更直接的语法支持却是大大增强了可读性。

下面是自创的一个新版 Type classes Pattern「记忆语法」

[使用]编译器在[作用域内]找到的[给定实例]

[using].............[given import]......[given instance]

Extension Method

在 Scala2 中要实现函数扩展得基于 implicit class，但是光看名字很难将这两者关联起来。

好在 Scala3 也注意到了这个问题，索性就之间新增了一个extension method 的特性，实际就是函数扩展。

Extension method 是一种新的函数定义语法（忘记 implicit class 吧），参考下面的代码

trait Comparator[T] {
  def compare[T](a: T, b: T): Int
  
  def (a: T) >(b: T) = compare(a, b) > 0
  def (a: T) <(b: T) = compare(a, b) < 0
}

> 和 < 就是全新的函数扩展语法

  • a: T 就是需要扩展函数的类型

  • b: T 就是函数的实际参数

假设 T 为 String 类型，那么我们就可以直接写出下面的中缀式调用语法

// 为字符串扩展了 > 函数
"ok".>("hello")

// 也可以省略 . 和括号
"ok"  > "hello"

除了为类型扩展函数外，该语法也可以实现 Scala2 的隐式方法的功能。

我们将 Scala2 中 implicit def listComparator 实例用 extension method 的语法再实现一遍（还需要借助 using）

object ComparatorInstances {
  
  // ......
  
  def [T](a: List[T]) listInstance(using cmp: Comparator[T]): Comparator[List[T]] = new Comparator[List[T]] {
    override def compare(a: List[T], b: List[T]): Int = {
      (a, b) match {
        case (Nil, Nil) => 0
        case (Nil, _) => 1
        case (_, Nil) => -1
        case (l, r) =>
          cmp.compare(l.head, r.head) match {
            case 0 => compare(l.tail, r.tail)
            case num => num
          }
      }
    }
  }
}

旧瓶装新酒？

如果你已经跨过了隐式系统那道门槛，这样的语法改变可能并不会给你带来多大的惊喜，感觉就像旧瓶装新酒一样，似乎没多大的新意？

而在我看来这样的「旧瓶装新酒」却是 Scala 提升亲和力的体现，当然 Scala3 也不止这些改变，更多特性可以参考 https://dotty.epfl.ch/docs/reference/overview.html。

比较 Scala2 与 Scala3

given、using、extension method 等特性在 Scala3 被统一称之为抽象上下文（Contextual Abstractions），前面已经或多或少拿它们与 Scala2 的隐式系统做过参照了。

不过这里还是打算单独拿出来对比一下，就相当于一个简单的总结吧。

1、 given 可以当做无参的 implicit object 或 implicit val

given intComparator as Comparator[INT] { ... }

implicit object intComparator Comparator Ord[Int] { ... }

implicit val intComparator = new Comparator[Int] { ... }

2、using 可以当做以前的隐式参数

def same[T](a: T, b: T)(using cmp: Comparator[T]) {...}

def same[T](a: T, b: T)(implicit cmp: Comparator[T]) {...}

3、extension method 可以当做以前的隐式类

trait Comparator[T] {
  def compare(a: T, b: T): Int

  def (a: T) >(b: T) = compare(a, b) > 0
  def (a: T) <(b: T) = compare(a, b) < 0
}

implicit class ComparatorOps[T](a: T)(implicit cmp: Comparator[T]) {
    def <(b: T) = cmp.compare(a, b) < 0

    def >(b: T) = cmp.compare(a, b) > 0
}

一些期待

开发者们一直喜欢拿 Scala 和 Haskell、Java 作比较，甚至在对应社区一直有这样的声音

  • A worse Haskell for the JVM

  • A better Java

造成这些印象的原因是 Scala 融合了 OOP 和 FP 两种编程范式，但这也恰好是 Scala 一直坚持的方向。

随着 Scala3 的发布，是不是会带来不一样的惊喜呢？有点期待

参考

  1. Dotty: A next-generation compiler for Scala：https://dotty.epfl.ch/

  2. 《The Limitations of Type Classes as Subtyped Implicits》：https://www.adelbertc.com/publications/typeclasses-scala17.pdf

  3. Scala Type Classes comparison：https://medium.com/se-notes-by-alexey-novakov/scala-type-classes-comparison-28b76ce1f37a

  4. preparing_for_scala_3_PPT：https://www.slidestalk.com/u39/preparing_for_scala_3_light_bend_vsjjhm

全文完

以下文章您可能也会感兴趣：

我们正在招聘 Java 工程师，欢迎有兴趣的同学投递简历到 rd-hr@xingren.com 。

杏仁技术站
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
scala-3 循环
a3125504x的博客
07-09 228
scala循环scala循环for循环for循环之守卫for推导式while循环 scala循环 scala支持for循环和while循环。推荐使用更简洁的for循环 for循环 语法 //每次循环将表达式/数组/集合的值赋给i //不用声明i的类型，scala可以自动推断 for（i <- 表达式/数组/集合）{ //表达式 } //双重循环用分号隔开 两个循环条件即可 for(i <- 表达式/数组/集合;j <- 表达式/数组/集合) { //表达式 } 示例 //1 t
喵喵：DottyScala 3中的无猫类别理论喵喵〜
02-15
标题 布局 喵 主要的 分类理论中的实验性无猫Dotty / Scala 3，喵〜 GADT 等级N类型 功能K 幻影类型 函子 Extension扩展 用法 sbt test
Windows 安装 Scala3
weixin_41427508的博客
03-20 2098
Windows 安装 Scala3
使用class对象作为参数化类型_真的学不动了： 除了 class , 也该了解 Type classes 了
weixin_39623620的博客
11-23 267
前言作为一个 Java 开发者， class 的概念肯定是耳熟能详了，可是在山的另一边还有拥有别样风情的 type classes，但不翻过 Java 这座山，它就始终隔着一层纱。一个经典的问题在编程中，经常需要判断两个值是否相等，而在很长的一段时间内这个问题都没有一个标准的解决方案，这就是经典的判等问题。 我这里统一使用 “值” 来代替对象、基本类型等等概念，以便于简化沟通在 Java 中，我...
scala3 scala3 scala3 scala3 scala3
02-19
scala3 scala3 scala3 scala3 scala3
scala3-sample-classes
03-28
scala3-sample-classs
scala-newtype：Scala的NewType，没有运行时开销
02-05
scala-newtype：Scala的NewType，没有运行时开销
jackson-module-scala3-enum:Jackson对Scala3枚举的支持
04-13
杰克逊模块scala3-枚举 Jackson支持Scala3。 libraryDependencies += "com.fasterxml.jackson.module" %% "jackson-module-scala3-enum" % "2.12.0" import com.github.pjfanning.`enum`.EnumModule val mapper = ...
基于scala的小型超市管理系统的设计与实现
最新发布
02-25
基于scala的小型超市管理系统的设计与实现
怒了！TypeClass什么时候变得这么重要了？
杏仁技术站
08-26 364
作者 | vranHello, 麻烦给我的代码来一杯 Mojito前言作为一个 Java 开发者，class的概念肯定是耳熟能详了，可是在山的另一边还有拥有别样风情的type c...
scala3
sisteryaya的博客
05-24 874
对列表、映射的遍历、foreach、s.toUpperCase、map、flatMap、reduce、wordcount
scala3-tuple
singkingcho的专栏
09-23 159
元组概念 Java里面没有这个概念，类似python这样的语法内置了元组，所谓元组就是一种可以包含不同数据类型的数据集 比如我们同时描述一个人的年龄，狗的名称，和你喜欢的球员，并且我们只是简单的使用，并不会大面积的复用，这个时候你怎么做 构建多个变量 构建一个Java类模型承载数据 元组 创建元组 比如我们创建三个元素的元组 val tp = new Tuple3(18,"小黄","wade") 数字3代表几个元素，这种写法稍显啰嗦，scala提供了更简单的方式，前面的new以及Tuple都省略 va
在Scala中提取两个字符串之间的差异，交集和不同字符
cumtv80668的专栏
08-03 751
Given two strings, we have to find the difference, intersections, and distinct characters between two strings. 给定两个字符串，我们必须找到两个字符串之间的差异，交点和不同字符。 两根弦之间的区别 (Difference between two strings) The differ...
Scala3 Macro系统Tasty进展
htgoco的博客
11-21 889
Scala3 重新设计了Macro系统，这是官网英文原文。 翻译的很烂，全当学习笔记而已，仅供参考 Or: Scala in a (Tasty) Nutshell 如何迁移到 Scala 3这篇博文中提到最大的一个问题是关于宏的问题。 目前我们正在努力将Tasty和macros对齐，接下来谈一谈我们的想法. What is Tasty? Tasty是Scala3的高级交换格式。它基于类型化的抽象语...
a7_scala三元运算
qq_43192537的博客
07-05 1万+
目录三元运算 三元运算 Scala 中任意表达式都是有返回值的，也就意味着 if else 表达式其实是有返回结果的,可以历用这个特性进行三元运算 举例 ：Scala 中任意表达式都是有返回值 三元运算 ...
第78讲：scala 中Type与Class初步学习
08-09 3447
概要由于在scala中非常强调泛型或者说类型系统 ，Java和scala是基于jvm的， java1.5以前具体对象的类型与class一一对应，后来引入泛型，如字符串数组或整数数组，都是数组 ，但其实类型是不一样的，在虚拟机内部，并不关心泛型或类型系统。 对泛型支持是基于运行时角度考虑的，在虚拟机中泛型被编译运行时是被擦除的， 在运行时泛型是通过反射方式获取。一、type 与 class 概念
Scala教程-详细全部
热门推荐
冰冰冰
02-02 3万+
第1章 数仓分层 1.1 为什么要分层 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H5Xc3t25-1612253300862)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20210202095729086.png)] 1.2 数据集市与数据仓库概念 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9yCemzyJ-1612253300866)(C:\User
TensorFlow系列——13、TensorFlow实现基于LSTM的语言模型
我的博客
01-29 398
2 3
解释：scala error: target\classes does not exist or is not a directory
07-15
这个错误通常出现在使用Scala编译器时，它指示目标目录`target\classes`不存在或不是一个目录。编译器通常将编译后的类文件输出到这个目录。 要解决这个问题，你可以尝试以下步骤： 1. 确保你的项目目录中包含名为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值