Question

MWE (obs.: I am avoiding to have to instantiate a class every call of c, this is why functions are desired):

object Main extends  App {
     def a(s:String, i:Int) ={
        s + i * i         //some complex op that yields String
     }

     def b(i:Int) ={
        i / 3             //another complex op that yields Int
     }

     def c(f: Any => Any) = { 
        val L = List(1,2,3,4) //list of complex elements
        L map f               //apply f within some complex loop
     }

     println(c(a))
     /*
        scala: type mismatch;
        found   : (String, Int) => String
        required: Any => Any
        println(c(a))
                  ^
      */

     println(c(b))
     /*
        scala: type mismatch;
        found   : Int => Int
        required: Any => Any
        println(c(b))
                  ^
     */
}

Maybe an equivalent question would be “Is there some kind of function inheritance?”,
like

def f
def fa(i: Int):String extends f
def fb(s: String):Int extends f

Answer 1

What you’re trying to do isn’t type-safe, since if it were you could pass a String to a function which takes an Int parameter:

e.g.

def c(f: Any => Any) = { 
    val L = List("a", "b", "c")
    L map f
}

c(a)

However you can take a function of type Int => Any, since it is safe to assign a more derived type to Any.

def c(f: Int => Any) = {
    val l = List(1,2,3,4)
    l.map(f)
}

This is now safe:

val bList: List[Any] = c(b)

You still can’t pass a to c however, since it requires two arguments instead of one. You can partially apply the first String argument and pass that:

val cList = c(a("SomeString", _:Int))