第一个示例成功找到了对方法的隐式转换foo(String),但是只要我添加一个类型参数(请参阅fails参考资料),编译就不再解析它了:
object works {
class A {
def foo(): String = ???
}
implicit class PimpedA(a: A) {
def foo(i: String): String = ???
}
val a = new A()
a.foo("test") //compiles
}
object fails { //same as `works`, but adds type parameter
class A {
def foo[T](): String = ???
}
implicit class PimpedA(a: A) {
def foo[T](i: String): String = ???
}
val a = new A()
PimpedA(a).foo("test") // compiles
a.foo("test") // error: too …在使用不同的排序算法时,我很惊讶Groovy关闭的表现非常糟糕.到目前为止我找不到一个好的答案,所以现在试试我的运气;)为什么Groovy闭包比传统方法慢得多？
这是一个显示性能差异的简单示例.它创建两个带有随机数的列表,并按相反的顺序对它们进行排序,测量排序时间.在我的机器和10k元素上,使用闭包需要270ms,使用Comparator实现只需50ms.
根据随机数的分布,时间稍有不同.我也尝试了Groovy 1.7.4和1.8.0,后者的性能稍好一些.但整体情况保持不变:关闭表现不佳.
我该怎么做才能提高闭合性能？当然,除了不使用闭包之外;)我是否遗漏了某些东西,或者如果性能很重要,是否应该在groovy中使用闭包？
def numberCount = 10000
def random = new Random()
def unorderedList1 = (1..numberCount).collect{random.nextInt()}
def unorderedList2 = (1..numberCount).collect{random.nextInt()}
def timeit = {String message, Closure cl->
def startTime = System.currentTimeMillis()
cl()
def deltaTime = System.currentTimeMillis() - startTime
println "$message: \ttime: $deltaTime"
}
timeit("compare using closure") {
def comparator= [ compare: { a,b -> return b <=> a }] as Comparator
unorderedList1.sort(comparator)
}
timeit("compare using method") {
Comparator comparator = new MyComparator()
unorderedList2.sort(comparator)
} …类型级别foldRight工作正常(getLabelWithValues),后续类型级别map(getValues)也可以正常工作.如果我在一个方法(getValuesFull)中组合两者,它就不再起作用了.丢失的是什么？
完整的源代码(sbt准备好~run使用隐式调试输出)在这里:https://github.com/mpollmeier/shapeless-playground/tree/8170a5b
case class Label[A](name: String)
case class LabelWithValue[A](label: Label[A], value: A)
val label1 = Label[Int]("a")
val labels = label1 :: HNil
object combineLabelWithValue extends Poly2 {
implicit def atLabel[A, B <: HList] = at[Label[A], (B, Map[String, Any])] {
case (label, (acc, values)) ?
(LabelWithValue(label, values(label.name).asInstanceOf[A]) :: acc, values)
}
}
object GetLabelValue extends (LabelWithValue ~> Id) {
def apply[B](labelWithValue: LabelWithValue[B]) = labelWithValue.value
}
val labelsWithValues: LabelWithValue[Int] :: HNil = getLabelWithValues(labels) …该方法doesNotCompile仅接受仅包含Label[A]条目的HLists .有一个Mapper可以将Label [A]转换为String(准确地说:) Const[String]#?.但是,当我应用映射器时,返回类型为ev1.Out.我知道这实际上只是一个只有字符串的HList,但我怎么能说服编译器呢？
import shapeless._
import shapeless.poly._
import shapeless.ops.hlist._
import shapeless.UnaryTCConstraint._
object Util {
case class Label[A](name: String, value: A)
object GetLabelName extends (Label ~> Const[String]#?) {
def apply[A](label: Label[A]) = label.name
}
}
object Main {
import Util._
def bar(l: List[String]) = ???
def compiles = {
val names = "a" :: "b" :: HNil
bar(names.toList)
}
// A is an HList whose members are all Label[_]
def doesNotCompile[A <: HList : *->*[Label]#?](labels: …给定一个HList Label[A](String)我想将它映射到HList LabelWithValue[A](Label[A], A),其中实际值来自a Map[String, Any].在下面的示例中,我只是在方法中定义了值的映射,只是想象值来自数据库.
下面的工作,但它是非常veckery hacky因为它使用全局变量.相反,我想Map[String, Any]进入GetLabelWithValue.我没有找到方法,因为调用者getValues隐式创建了一个Mapper,并且此时值的映射尚不存在.我自己尝试创建一个Mapper,但我的类型级编程技能还不够好.
import shapeless._
import shapeless.poly._
import shapeless.ops.hlist._
object Main extends App {
case class Label[A](name: String)
case class LabelWithValue[A](label: Label[A], value: A)
// TODO: avoid the horrible global state - pass in the Map as a parameter
var horribleGlobalState: Map[String, Any] = _
object GetLabelWithValue extends (Label ~> LabelWithValue) {
def apply[A](label: Label[A]) =
LabelWithValue(label, horribleGlobalState.get(label.name).asInstanceOf[A])
}
val label1 = Label[Int]("a")
val label2 …给定一个A具有类型参数的类，T我如何进一步约束T特定函数？在下面的示例中，我想强制执行foo只能在T是Int（或子类型，如果您愿意）时调用。即new A[Int]().foo()应该编译，但new A[Double]().foo()不应该编译。
我可以通过隐式转换实现我想要的，T => Int如foo. 然而，这会导致不必要的方法调用 - 隐式找到的证据是身份函数。还有，不好看。。。
class A[T] {
val someValue: T = ???
def foo()(implicit ev: T => Int): Int = ev(someValue)
// some ideas that don't quite work
// def bar[T2 <: Int :EqualTo[T]](t2: T2): T = t2.asInstanceOf[T]
// def bam[T2 <: T with Int](): Int = someValue.asInstanceOf[Int]
def thisOneDefinesItsOwnConstraintType[Z <: Int](z: Z): Z = …