让我们考虑一个具体的例子。我有许多函数,它们接受可变数量的参数,并返回一个Seq[T]。可以这样说:
def nonNeg(start: Int, count: Int): Seq[Int] =
Iterator.from(start).take(count).toSeq对于这些函数中的每一个,我需要创建该函数的"Java版本“,并返回一个java.util.List[T]。我可以使用以下方法创建上述函数的"Java版本“:
def javaNonNeg(start: Int, count: Int): java.util.List[Int] =
nonNeg(start, count).asJava这有点冗长,因为参数列表重复了两次。相反,我希望创建一个更高级别的函数,它以nonNeg形式的函数(参数的任何数目和类型,返回一个Seq[T])作为参数,并返回一个函数,该函数接受相同的参数,但返回一个java.util.List[T]。假设这个函数被称为makeJava,那么我就可以编写:
def javaNonNeg = makeJava(nonNeg)makeJava可以用Shapeless能力写成abstracting over arity吗?如果可以,怎么做,怎么做,为什么,怎么做?
发布于 2014-08-07 18:26:02
可以使用无形状的方法来避免样板--您只需使用普通的eta展开将原始方法转换为FunctionN,然后转换为接受单个HList参数的函数,然后返回到具有新结果类型的FunctionN:
import java.util.{ List => JList }
import shapeless._, ops.function._
import scala.collection.JavaConverters._
def makeJava[F, A, L, S, R](f: F)(implicit
ftp: FnToProduct.Aux[F, L => S],
ev: S <:< Seq[R],
ffp: FnFromProduct[L => JList[R]]
) = ffp(l => ev(ftp(f)(l)).asJava)然后:
scala> def nonNeg(start: Int, count: Int): Seq[Int] =
| Iterator.from(start).take(count).toSeq
nonNeg: (start: Int, count: Int)Seq[Int]
scala> val javaNonNeg = makeJava(nonNeg _)
javaNonNeg: (Int, Int) => java.util.List[Int] = <function2>
scala> javaNonNeg(1, 4)
res0: java.util.List[Int] = [1, 2, 3, 4]javaNonNeg是一个Function2,所以您可以在Java中使用javaNonNeg.apply(1, 4)。
发布于 2014-08-06 06:44:29
对于2或更多的参数(在下面的代码中),您可以使用隐式参数特性,以便按输入参数类型解析结果类型。
sealed trait FuncRes[F] {
type Param
type Result
def func : F => Param => Result
}
class Func[T, R](fn : T => R) {
trait FR[F, P] extends FuncRes[F] { type Param = P; type Result = R }
implicit def func2[T1,T2] = new FR[(T1,T2) => T, (T1,T2)] {
def func = f => p => fn(f.tupled(p))
}
implicit def func3[T1,T2,T3] = new FR[(T1,T2,T3) => T, (T1,T2,T3)] {
def func = f => p => fn(f.tupled(p))
}
implicit def func4[T1,T2,T3,T4] = new FR[(T1,T2,T3,T4) => T, (T1,T2,T3,T4)] {
def func = f => p => fn(f.tupled(p))
}
def makeFunc[F](f : F)(implicit ev : FuncRes[F]): ev.Param => ev.Result =
ev.func(f)
}在def javaNonNeg = makeJava(nonNeg)函数之后,如下所示:
object asJavaFunc extends Func((_ : Seq[Int]).asJava)
import asJavaFunc._
def javaNonNeq = makeFunc(nonNeg _) 当然,它也有一些缺点,但通常它能满足你的需要。
https://stackoverflow.com/questions/25149179
复制相似问题