Scalaz(1)- 基础篇:隐式转换解析策略-Implicit resolution

在正式进入scalaz讨论前我们需要理顺一些基础的scalaz结构组成概念和技巧。scalaz是由即兴多态(ad-hoc polymorphism)类型(typeclass)组成。scalaz typeclass在scala中的应用有赖于scala compiler的一项特别功能:隐式转换(implicit conversion),使程序表述更精简。由于隐式转换是一项compiler功能,在程序编译(compile)的时候是由compiler来进行类型转换代码的产生和替代的。

  让我们先了解一下作用域(scope)和绑定(binding)。这两样都是在编译程序时compiler需要解决的问题。所谓作用域解析(scope resolution)就是要确定一个绑定在一个作用域里是可视的,否则程序无法通过编译。

作用域就是一个绑定在一个程序范围内的可视型。作用域可以是某个类的内部或者是某个方法或函数的内部,基本上用{}就可以创造一个新的作用域了。在scala作用域可以是多层的,一个域可以存在于另一个作用域内。外部域的绑定在内部域内是可视的,反之则不然:

1 class Foo(x: Int) {
2   def temp = {
3     val y = x + 1  //x是本地域外的一个绑定
4   }  
5 }

在以上的例子里x在temp{}内是可视的。一个作用域内的绑定可以屏蔽(shadow)外域定义的绑定:

1 class Foo(x: Int) {
2   def temp = {
3     val x = 0      //本地域绑定。屏蔽了外域的x
4     val y = x + 1  //y=1,x是本地域的一个绑定
5   }  
6 }

绑定屏蔽是分优先次序如下:

1、本地声明、定义或者透过继承又或者在同一源代码文件内的package定义的绑定最优先

2、明式申明的import如:import obj.Foo 所定义的绑定次优先

3、通配符式的import如:import obj._ 所定义的绑定再次之

4、同一package但处于不同源代码文件内的绑定最次优先

我们用个例子来示范scope binding的优先顺序:

 1 package test;
 2 
 3 // This object contains the bindings/scope tests
 4 object Test {
 5 
 6   def main(arg : Array[String]) : Unit = {
 7     testSamePackage()
 8     testWildcardImport()
 9     testExplicitImport()
10     testInlineDefinition()
11   }
12 
13   // This looks for a binding 'x' within the same package (test) as this scope.
14   def testSamePackage() {
15      println(x)  // 在另外文件的test package. prints: Externally bound x object in package test
16   }
17 
18   // This defines a new scope with an 'x' binding that we can import with a wildcard.
19   object Wildcard {
20     def x = "Wildcard Import x"
21   }
22 
23   // This function will print the value in the binding 'x' after importing from the Wildcard object
24   // using a wildcard import.
25   def testWildcardImport() {
26     import Wildcard._
27     println(x)  // prints: Wildcard Import x
28   }
29 
30   // This defines another binding of 'x' that we can import explicitly.
31   object Explicit {
32     def x = "Explicit Import x"
33   }
34 
35   def testExplicitImport() {
36     import Explicit.x  
37     import Wildcard._
38     println(x)  // .x优先于._  prints: Explicit Import x
39   }
40 
41   // This defines an inline binding for x.  Note that with all the imports, there are no ambiguous naming conflicts.
42   def testInlineDefinition() {
43     val x = "Inline definition x" //即使写在最前,本地binding x还是最优先
44     import Explicit.x
45     import Wildcard._
46     println(x)  // prints:  Inline definition x
47   }
48 }

scala compiler 在编译程序时会根据情况自动进行隐式转换,即代码替代。在两种情况下scala会进行隐形转换:

1、在期待一个类型的地方发现了另外一个类型:

 1 package learn.scalaz
 2 object ab {
 3  class A
 4  class B
 5  implicit def bToA(x: B): A = new A
 6 }
 7 object testApp extends App {
 8   import ab._
 9   val a: A = new B  //需要进行B => A的隐式转换
10 }

在这里由于A类和B类没有任何继承关系,应该无法通过编译,但scala compiler会首先尝试搜寻B=>A的隐式转换实例,当找到bToA函数时compiler会把new B替代成bToA(new B),如此这般才能通过编译。

2、当一个类型并不支持某个方法时:

 1 package learn.scalaz
 2 object ab {
 3  class A {
 4    def printA = println("I am A")   
 5  }
 6  class B
 7  implicit def bToA(x: B): A = new A
 8 }
 9 object testApp extends App {
10   import ab._
11   (new B).printA   //需要进行B => A的隐式转换
12 }

scala compiler 在隐式转换中的隐式解析(implicit resolution)会用以下的策略来查找标示为implicit的实例:

1、能用作用域解析的不带前缀的隐式绑定即:如Bar,而Foo.Bar则不符合要求

这个在以上的例子里已经示范证明了。

2、如果以上方式无法解析隐式转换的话compiler会搜寻目标类型的隐式作用域(implicit scope)内任何对象中的隐式转换。一个类型的隐式作用域(implicit scope)包括了涉及这个类型的所有伴生模块(companion module)内定义的隐式转换。例如:

def foo(implicit p: Foo),这个方法的参数必须是Foo类型。如果compiler无法进行作用域解析的话就必须搜寻隐式作用域内的匹配隐式转换。比如Foo的伴生对象(companion object),如下:

 1 object demo {
 2  object Container {
 3    trait Foo
 4    object Foo {
 5          implicit def x = new Foo {
 6             override def toString = "implicit x"
 7         }
 8    }
 9  }
10  import Container._
11  def foo(implicit p: Foo) = println(p)            //> foo: (implicit p: scalaz.learn.ex1.Container.Foo)Unit
12  foo                                              //> implicit x

compiler在object Foo内找到了匹配的隐式转换,程序通过了编译。

由于compiler会首先进行作用域解析,失败后才搜寻隐式转换作用域,所以我们可以把一些默认隐式转换放到隐式作用域里。然后其它编程人员可以通过import来覆载(override)使用他们自己的隐式转换。

综合以上所述:一个类型T的隐式作用域就是组成这个类型的所有类的伴生对象(companion object)。也就是说,T的形成有可能涉及到一组类型。在进行隐式转换解析过程中,compiler会搜寻这些类型的伴生对象。类型T的组成部分如下:

1、所有类型T的父类:

 1 object demo {
 2  object Container {
 3    trait A
 4    trait B
 5    class T extends A with B
 6    object A {
 7     implicit def x = new T {
 8             override def toString = "implicit x"
 9         }
10    }
11  }
12  import Container._
13  def foo(implicit p: T) = println(p)            //> foo: (implicit p: scalaz.learn.demo.Container.Foo)Unit
14  foo                                              //> implicit x

类型T由A,B组成。compiler从A的伴生对象中解析到隐式转换。

2、如果T是参数化类型,那么所有类型参数的组成类型及包嵌类的组成类型的伴生对象都在隐式转换解析域中。如在解析List[String]中,所有List和String的伴生对象都在解析域中:

 1 object demo {
 2  object Container {
 3    trait A
 4    trait B
 5    class T[A]
 6    object A {
 7     implicit def x = new T[A] {
 8             override def toString = "implicit x"
 9         }
10    }
11  }
12  import Container._
13  def foo(implicit p: T[A]) = println(p)           //> foo: (implicit p: scalaz.learn.demo.Container.T[scalaz.learn.demo.Container.
14                                                   //| A])Unit
15  foo                                              //> implicit x

A是T[A]的类型参数。compiler从A的伴生对象中解析到隐式转换。

3、如果T是个单例对象(singleton object),那么T的包嵌对象(container object)就是解析域:

 1 object demo {
 2  object Container {
 3    object T {
 4      def x = "singleton object T"
 5    }
 6    implicit def x =  T 
 7  }
 8  import Container._
 9  def foo(implicit p: T.type) = println(p.x)       //> foo: (implicit p: scalaz.learn.demo.Container.T.type)Unit
10  foo                                              //> singleton object T

单例对象T定义于包嵌对象Container内。compiler从Container中解析到隐式转换。

这是一篇隐式转换解析原理的讨论,不会对scala有关隐式转换语法和调用做任何解说,希望读者体谅。

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

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Deep learning进阶路

C++随记(七)--引用变量

C++随记(七)--引用变量 引用变量是C++新增的一种复合类型。引用是 已定义的变量的一个别名(另一个名称)。引用变量的主要用途是用作函数的形参,如果将引用变...

1830
来自专栏软件开发

JavaSE学习总结(四)——Java面向对象十分钟入门

面向对象编程(Object Oriented Programming,OOP)是一种计算机模拟人类的自然思维方式的编程架构技术,解决了传统结构化开发方法中客观...

2377
来自专栏有趣的Python

3-Linux C语言结构体-学习笔记

将#include <stdio.h>中stdio.h展开,将未注释的内容直接写入.i文件。

851
来自专栏对角另一面

读 Zepto 源码之集合元素查找

这篇依然是跟 dom 相关的方法,侧重点是跟集合元素查找相关的方法。 读Zepto源码系列文章已经放到了github上,欢迎star: reading-zept...

1910
来自专栏微信公众号:Java团长

Java泛型详解

Java泛型是jdk1.5中引入的一个新特性,泛型提供了编译时的类型检测机制,该机制允许程序员在编译时检测到非法的类型。 泛型是Java中一个非常重要的知识点,...

511
来自专栏有趣的Python

8-Java基础语法-Java方法

类,Scanner是一个类,sc是它实例化出的对象。nextInt()是从键盘获取一个整型值的方法,next()是从键盘获取一个字符串类型值的方法。这两个都是使...

381
来自专栏码匠的流水账

easy-rules小试牛刀

easy-rules-core-3.1.0-sources.jar!/org/jeasy/rules/api/Rule.java

531
来自专栏Android 研究

OKHttp源码解析(五)--OKIO简介及FileSystem

okio是由square公司开发的,它补充了java.io和java.nio的不足,以便能够更加方便,快速的访问、存储和处理你的数据。OKHttp底层也是用该库...

702
来自专栏Kevin-ZhangCG

[ Java学习基础 ] Java的继承与多态

1966
来自专栏屈定‘s Blog

Java8 Lambda(二)-Stream原理

推荐一篇博文,很好的介绍了Stream的原理.本文对其进行一些补充更加详细的讲解.

662

扫码关注云+社区