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

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 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 }

 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 }

 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 }

 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

 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

 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

 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