コンテキスト境界は、それを使用する他のメソッドに渡す必要がある場合のみ便利です。たとえば、sortedのメソッドにはSeq暗黙の が必要ですOrdering。メソッド を作成するにはreverseSort、次のように記述します。

def reverseSort[T : Ordering](seq: Seq[T]) = seq.sorted.reverse

Ordering[T]は暗黙的に に渡されたためreverseSort、それを暗黙的に に渡すことができますsorted。

Implicits はどこから来るのでしょうか?

オブジェクトのクラスに存在しないメソッドを呼び出しているか、暗黙的なパラメータを必要とするメソッドを呼び出しているために、コンパイラが暗黙的な必要性を認識すると、コンパイラはニーズに適合する暗黙的な値を検索します。

この検索は、どの暗黙的要素が可視でどれが不可視かを定義する特定のルールに従います。コンパイラが暗黙的要素を検索する場所を示す次の表は、優れたプレゼンテーション(タイムスタンプ 20:20) Josh Suereth による implicit に関する記事です。Scala の知識を向上させたい方には心からお勧めします。それ以降、フィードバックや更新によって記事は補完されてきました。

以下の 1 番で利用可能な暗黙の引数は、2 番で利用可能な暗黙の引数よりも優先されます。それ以外に、暗黙のパラメータの型に一致する適格な引数が複数ある場合は、静的オーバーロード解決のルールを使用して最も具体的な引数が選択されます (Scala 仕様 §6.26.3 を参照)。より詳細な情報は、この回答の最後にリンクしている質問に記載されています。

1. 現在のスコープでの最初の外観
   • 現在のスコープで定義されている暗黙的要素
   • 明示的なインポート
   • ワイルドカードインポート
   • 他のファイルでも同じスコープ
2. 次に、関連型を見てみましょう。
   • タイプのコンパニオンオブジェクト
   • 引数の型の暗黙的なスコープ(2.9.1)
   • 型引数の暗黙的なスコープ(2.8.0)
   • ネストされた型の外部オブジェクト
   • その他の次元

いくつか例を挙げてみましょう:

現在のスコープで定義されている暗黙的要素

implicit val n: Int = 5
def add(x: Int)(implicit y: Int) = x + y
add(5) // takes n from the current scope

import scala.collection.JavaConversions.mapAsScalaMap
def env = System.getenv() // Java map
val term = env("TERM")    // implicit conversion from Java Map to Scala Map

def sum[T : Integral](list: List[T]): T = {
    val integral = implicitly[Integral[T]]
    import integral._   // get the implicits in question into scope
    list.foldLeft(integral.zero)(_ + _)
}

for {
    x <- List(1, 2, 3)
    y <- Some('x')
} yield (x, y)

List(1, 2, 3).flatMap(x => Some('x').map(y => (x, y)))

List(1, 2, 3).sorted

class A(val n: Int)
object A { 
    implicit def str(a: A) = "A: %d" format a.n
}
class B(val x: Int, y: Int) extends A(y)
val b = new B(5, 2)
val s: String = b  // s == "A: 2"

class A(val n: Int) {
  def +(other: A) = new A(n + other.n)
}
object A {
  implicit def fromInt(n: Int) = new A(n)
}

// This becomes possible:
1 + new A(1)
// because it is converted into this:
A.fromInt(1) + new A(1)

class A(val n: Int)
object A {
    implicit val ord = new Ordering[A] {
        def compare(x: A, y: A) = implicitly[Ordering[Int]].compare(x.n, y.n)
    }
}

List(new A(5), new A(2)).sorted

class A(val n: Int) {
  class B(val m: Int) { require(m < n) }
}
object A {
  implicit def bToString(b: A#B) = "B: %d" format b.m
}
val a = new A(5)
val b = new a.B(3)
val s: String = b  // s == "B: 3"