在scala中，类成员的参数化返回类型是匿名函数

Question

What I want is something like the following:

class Foo(val f: (Bar => A) => A) {
  def consume(x: Int): Unit = {
    val myStr: String = f(bar => bar.getStr)
    val myInt: Int    = f(bar => bar.getInt)
    writeToLog(s"$myStr: ${myInt + x}")
  }
}

I know I could do this by defining a type for f with an apply method that takes type parameters. My question is can I achieve this without defining such a type? BTW, I don't use a Bar directly because each Bar is an rpc object (eg thrift) and I have set up and tear down boilerplate code that I'm avoiding with this pattern.

Answer 1

I'm not sure that it's exactly what you need, but I can suggest Polymorphic functions with Shapeless:

  import shapeless._
  import poly._

  class Bar {
    def getStr = "str"
    def getInt = 1
  }

  type Extractor[T] = Bar => T

  object extract extends Poly1 {
    implicit def caseStr = at[Extractor[String]](f => f.andThen(identity))
    implicit def caseInt = at[Extractor[Int]](f => f.andThen(identity))
  }

  class Foo(bar: Bar) {
    def e[T](f: Bar => T): Extractor[T] = f

    def consume(x: Int): Unit = {
      val myStr: String = extract(e(_.getStr)) apply bar
      val myInt: Int    = extract(e(_.getInt)) apply bar
      println(s"$myStr: ${myInt + x}")
    }
  }

  new Foo(new Bar).consume(1)

So you need to define function for each case (String, Int, etc). And I used just identity. In you example you never pass Bar, but you definitely need it at some point to calculate String and Int