스칼라 암시 적 함수가 매개 변수화 됨

Question

이 코드가 로컬 범위에 정의 된 암시 적 함수를 사용하지 않는 이유는 무엇입니까? 다른 곳에서 암시 적 함수를 어디에서 가져 옵니까? 로컬 범위 내 암시 인증 된 정의의

def implctest[T](a: T)(implicit b:T=>T):T = {b apply a} 
class Testimplcl(val a:Int){ 
    override def toString() = "value of the 'a' is = "+a 
} 
implicit def dble(x: Int):Int = {x + x} 
implicit def stringer(x: String):String = {x+" no not a pity"} 
implicit def myclass(x: Testimplcl):Testimplcl = new Testimplcl(x.a +1) 

implctest[String]("oh what a pity") 
implctest[Int](5) 
implctest[Testimplcl](new Testimplcl(4)) 

없음이 촬영되지 않습니다. 를 예를 들어 implctestInt이 결과 5를 제공, 나는 그것이 암시 적으로 dble을 복용하여 10를 반환 할 것으로 예상된다.

오류도 표시되지 않습니다.

implicit val dble = (x: Int) => x + x 
implicit val stringer = (x: String) => x + " no not a pity" 
implicit val myclass = (x: Testimplcl) => new Testimplcl(x.a +1) 

후 즉시이 문제에 대한 이유가 표시됩니다. implctest은 단순히 당신이 THS처럼 implicits를 다시 작성할 경우에

Answer 1

는, 스칼라는 방법 정의에서 암시 적 상승을 제공, 같은

입니다

implicit def dble(x: Int):Int = x + x 

, 그것을 취급하는 함수 dble _로 . 따라서 암시 적 해결책에서는 즉각 가용 값이 아닙니다.

당신이 가진 문제는에 대한 암시 A => A이 때문이다 Predef.conforms로 정의 모든 종류의 : 당신이 A => B 및 A 일에서보기를 원할 때마다 때문에

def conforms[A]: <:<[A, A] // where <:< is a sub class of A => A 

이 유용하고 필요하다 B이되도록 이러한 "변환"이 자동으로 사용 가능합니다. 직접 기능

참조 :

implicitly[Int => Int] // look for an implicit conversion of that type 

<console>:49: error: ambiguous implicit values: 
both method conforms in object Predef of type [A]=> <:<[A,A] 
and value dble of type => Int => Int 
match expected type Int => Int 
       implicitly[Int => Int] 
         ^

---

그래서, 짧은에, 그것은 사용자 정의 A => A을 요청 좋지 않다 :

implicit val dble = (x: Int) => x + x 

당신은 충돌을 참조하십시오. 그런 것이 정말로 필요한 경우 Foo[A] extends (A => A)과 같은 사용자 정의 유형 클래스를 사용하십시오.

Answer 2

전달 된 인수를 반환합니다. 지금 당신은 모호한 암시 값으로 문제가 : 이것은 일반적으로 Predef 이미 암시 적 기능 T => T를 정의 있음을 알려줍니다

scala: ambiguous implicit values: 
    both method conforms in object Predef of type [A]=> <:<[A,A] 
and value stringer in object ReflectionTest of type => String => String 
match expected type String => String 
println(implctest[String]("oh what a pity")) 
       ^

을, 그래서 당신의 정의와 충돌.

암시 적 매개 변수로 Function과 같은 일반 유형을 사용하지 않는 것이 좋습니다. 이를 위해 고유 한 유형을 만드십시오. 마찬가지로이 예제 : 당신이 함수 A => A을 요청하는 경우

trait MyTransformer[T] extends (T => T) 

object MyTransformer { 
    def apply[T](fn: T => T) = new MyTransformer[T] { 
    def apply(v: T) = fn(v) 
    } 
} 

def implctest[T: MyTransformer](a: T): T = 
    implicitly[MyTransformer[T]] apply a 


class Testimplcl(val a:Int){ 
    override def toString() = "value of the 'a' is = "+a 
} 

implicit val dble = MyTransformer((x: Int) => x + x) 
implicit val stringer = MyTransformer((x: String) => x + " no not a pity") 
implicit val myclass = MyTransformer((x: Testimplcl) => new Testimplcl(x.a +1))