Question

I want to do this:

abstract class Context {
    def getInt(id: Int): Int
}

abstract class Dependency[+T]
(val name: String, val id: Int)
extends Function1[Context,T]

class IntDependency(name: String, id: Int)
extends Dependency[Int](name, id) {
    def apply(implicit context: Context): Int =
        context.getInt(id)
}

But then I get an error message like this:

class IntDependency needs to be abstract, since method apply in trait
Function1 of type (v1: Context)Long is not defined (Note that T1 does
not match Context)

I understand that implicits should normally be part of the second parameter list, but I can’t work out how to code it so it compiles, and gives the result I want.

Explanation: I’m trying to create a framework where one can define “Function” object, which can depend on other functions to compute their value. All functions should only take a single Context parameter. The context know the “result” of the other functions. The function instances should be immutable, with the state residing in the context. I want the functions to create “dependency” fields at creation time, which take the context implicitly, and return the value of the dependency within that context, so that accessing the dependency inside of the apply method “feels like” accessing a parameter or field, that is without explicitly giving the context as parameter to the dependency.

Answer 1

Are you sure you need your Dependency to extend a Function? Because if you don’t, just leave the extends Function1[Context,T] part out and your code will work.

If you really need to extend a Function than I don’t know of a solution in your case. But there are cases where you could try to overload the apply method. Like here:

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