[SCALA] Implicits와 스칼라 기능 리터럴

Implicits와 스칼라 기능 리터럴

이 이미 다른 곳에서 요청 된 경우 용서. 나는 함수 값과 암시 적 매개 변수를 포함하는 스칼라 구문 질문이 있습니다.

나는 스칼라의 태닝 기능이 implicits를 사용하여 편안 해요. 예를 들어 나는 sum 함수를했고, 두 번째 인수 암시를 만들고 싶었다 경우 :

scala> def sum(a: Int)(implicit b: Int) = a + b
sum: (a: Int)(implicit b: Int)Int

함수 값 구문을 사용하여이 작업을 수행 할 수있는 방법이 있나요? 잠시 암시를 무시하고, 나는 일반적으로이 같은 카레 함수 값을 기록 :

scala> val sum2 = (a: Int) => (b: Int) => a + b
sum: (Int) => (Int) => Int = <function1>

그러나, 두 번째 방법에서 서명 함수 다르지합니다 (태닝이 명시 적으로 표현되는)이다. 그냥 많은 이해가되지 않습니다 (B)로 암시 적 키워드를 추가하고 컴파일러가 아니라 불평 :

scala> val sum2 = (a: Int) => (implicit b: Int) => a + b
<console>:1: error: '=>' expected but ')' found.
       val sum2 = (a: Int) => (implicit b: Int) => a + b
                                              ^

또한 함수 값이 아니라 문제가 발생 얻을 최초 접근에서 합을 부분적으로 적용 :

scala> val sumFunction = sum _
<console>:14: error: could not find implicit value for parameter b: Int
       val sumFunction = sum _
                         ^

이 리드 나 암시 적 매개 변수가 함수 매개 변수 함수 값이 생성 될 때 함수 값은 나중에 적용하지 않을 경우 결정 말했다해야한다고 생각합니다. 이건 정말 사건인가요? 혹시 함수 값을 암시 적 매개 변수를 사용할 수 있습니까?

도와 주셔서 감사합니다!

해결법

1. ==============================

   1.

   scala>  val sum2 = (a: Int) => {implicit b: Int => a + b}
   sum2: (Int) => (Int) => Int = <function1>
   

   당신이 암시 적 지능을 기대 메소드를 호출 할 수 있도록 이것은 단지, 함수 본문의 범위에 대한 암시 값 b를 만들 것입니다.

   나는 다음 함수가 무엇인지 불분명하기 때문에이 기능에 대한 암시 인수를 가질 수 있다고 생각하지 않습니다. 그것은 지능 => Int 인 또는인가 () => Int 인?

   가장 가까운 I의 FOUND입니다 :

   scala> case class Foo(implicit b: Int) extends (Int => Int) {def apply(a: Int) = a + b}
   defined class Foo
   
   scala> implicit val b = 3
   b: Int = 3
   
   scala> Foo()
   res22: Foo = <function1>
   
   scala> res22(2)
   res23: Int = 5
   

2. ==============================

   2.이 조각에서

   이 조각에서

   scala> val sum2 = (a: Int) => (b: Int) => a + b
   sum: (Int) => (Int) => Int = <function1>
   

   SUM2의 정확한 형태는 기능 1 [INT, 기능 1 [INT, 지능]을 참고있다. 또한 같이 쓸 수있다

   val sum2 = new Function1[Int, Function1[Int, Int]] {
       def apply(a: Int) = new Function1[Int, Int] {
           def apply(b: Int) = a + b
       }
   }
   

   당신이 암시 b를 만들려고 지금, 만약, 당신이 얻을 :

   scala>     val sum2 = new Function1[Int, Function1[Int, Int]] {
        |         def apply(a: Int) = new Function1[Int, Int] {
        |             def apply(implicit b: Int) = a + b
        |         }
        |     }
   <console>:8: error: object creation impossible, since method apply in trait Function1 of type (v1: Int)Int is not defined
                  def apply(a: Int) = new Function1[Int, Int] {
                                          ^
   

   암시 적 매개 변수 것도이 기능되지 않도록 또는, 즉, 기능의 인터페이스는 암시 적 매개 변수가 없습니다.

3. ==============================

   3.(가) 방법을 적용 과부하보십시오.

   (가) 방법을 적용 과부하보십시오.

   scala> val sum = new Function1[Int, Function1[Int, Int]] {
            |      def apply(a: Int) = (b: Int) => a + b
            |      def apply(a: Int)(implicit b: Int) = a + b
            |}
   sum: java.lang.Object with (Int) => (Int) => Int{def apply(a:Int)(implicit b: Int): Int} = <function1>
   
   scala> sum(2)(3)
   res0: Int = 5
   
   scala> implicit val b = 10
   b: Int = 10
   
   scala> sum(2)
   res1: Int = 12
   

from https://stackoverflow.com/questions/6326132/scala-functional-literals-with-implicits by cc-by-sa and MIT license