Scala-使依赖于g的变量的高阶函数g的函数参数f签名

Question

I am trying to define a higher order function f which accepts a variable number of parameters args of type Wrapper[T]* and a function parameter g in Scala.

The function f should decapsulate each object passed in args and then call g with the decapsulated parameters. Therefore, g has to accept exactly the same number of parameters of type T as args contains.

The closest thing I could achieve was to pass a Seq[T] to g and to use pattern matching inside of g . Like the following:

f("This", "Is", "An", "Example")(x => x match {
  case Seq(a:String, b:String, c:String): //Do something.
})

With f defined like:

def f[V](args: Wrapper[T]*)
        (g: (Seq[T]) => (V)) : V = {
  val params = args.map(x => x.unwrap())
  g(params)
}

1. How is it possible to accomplish a thing like this without pattern matching?
2. It is possible to omit the types in the signature of g by using type inference, but only if the number of parameters is fixed. How could this be done in this case?
3. It is possible to pass different types of parameters into varargs, if a type wildcard is used args: Wrapper[_]* . Additionally, casting the result of x.unwrap to AnyRef and using pattern matching in g is necessary. This, however, completely breaks type inference and type safety. Is there a better way to make mixing types in the varargs possible in this special case?

I am also considering the use of scala makros to accomplish these tasks.

Answer 1

Did I get you right? I replaced your Wrapper with some known type, but that doesn't seem to be essential.

def f[T, V](args: T*)(g: PartialFunction[Seq[T], V]): V = g(args)

So later you can do this:

f(1,2,3) { case Seq(a,b,c) => c } // Int = 3

Okay, I've made my own Wrapper to be totally clear:

case class Wrapper[T](val x:T) { 
  def unwrap = x 
}

def f[V](args: Wrapper[_]*)(g: PartialFunction[Seq[_], V]): V =
  g(args.map(_.unwrap))

f(Wrapper("1"), Wrapper(1), Wrapper(BigInt(1))) {
  case Seq(s: String, i: Int, b: BigInt) => (s, i, b)
} // res3: (String, Int, BigInt) = (1,1,1)

Regarding your concerns about type safety and conversions: as you can see, there aren't any explicit conversions in the code above, and since you are going to pattern-match with explicitly defined types, you may not to worry about these things - if some items of an undefined origin are going to show in your input, scala.MatchError will be thrown.