将参数函数指定为输入，而不会在Scala中过度约束它们

Question

I've backed myself into an interesting corner while designing a higher order typed interface.

I want to do something like this

trait SomeTrait {
  def higherOrder(f: (Int, A) => List[A]): String
}

object SomeImple extends SomeTrait {
  def higherOrder(f: (Int, A) => List[A]): String = {
    f(3, "HI").mkString(", ") + f(3, 7).mkString(", ")
  }
}

I want to specify that a function takes another higher order function as input that works for any type (in this case A ). For instance:

def someFun[A](n: Int, a: A): List[A] =
  if (n <= 0) {
    List.empty
  } else {
    a :: (someFun(n - 1, a))
  }

However If a add a type parameter to the higherOrder that means the function f can only be used at one type. Is there a way to take parametric functions as inputs without overly constraining them?

Answer 1

You can't parameterize a function like that, but you can parameterize a method:

trait SomeTrait {
  def higherOrder(fn: {def apply[A](n: Int, a: A): List[A]}): String
}

object SomeImple extends SomeTrait {
  def higherOrder(f: {def apply[A](n: Int, a: A): List[A]}): String = {
    f(3, "HI").mkString(", ") + f(3, 7).mkString(", ")
  }
}

object someFun {
  def apply [A] (n: Int, a: A): List[A] = {
    if (n <= 0) {
      List.empty
    } else {
      a :: (someFun(n - 1, a))
    }
  }
}

Using a structural type (or you can create a trait that can be implemented by the type holding the method), you can request the method take a type param.

Unfortunately, you have to wrap it in an object (or some class) because a regular method can only be "lifted" to a Function and a Function 's type parameters are fixed at definition time.

For reference: https://gist.github.com/jdegoes/97459c0045f373f4eaf126998d8f65dc#polymorphic-functions

Answer 2

What's wrong with passing type to your function? Solution :

object HighOrderFunction {
    type MyFunction[T] = (Int, T) => List[T]

    def main(args: Array[String]): Unit = {

        val dupInt: MyFunction[Int] = (n, value) => {
            List.fill(n)(value)
        }

        val dupString: MyFunction[String] = (n, value) => {
            List.fill(n)(value)
        }

        val dupDouble: MyFunction[Double] = (n, value) => {
            List.fill(n)(value)
        }

        execute(dupInt, 5, 1)
        execute(dupString, 5, "*")
        execute(dupDouble, 5, 3.14)

    }


    def execute[T](f: MyFunction[T], n: Int, t: T): Unit = {
        println(f(n, t))
    }
}