小编Mat*_*t R的帖子

是否有一种简单的方法来转换

java.lang.Iterable[_]

到了

Scala.Iterable[_]

？

我正在使用Docker(1.3.1)在容器内构建RPM:

docker run -v /home/matt/build:/build build-rpm /build/build-pkg.sh

这工作正常(我的用户在docker组中,因此我不需要sudo)并.rpm在当前目录中删除已完成的文件.问题是该文件是由root拥有的.

我如何安排它,以便创建文件由我运行docker的同一用户拥有？

与Java不同,Scala允许您在没有catch或finally子句的情况下进行"尝试":

scala> try { println("Foo") }
Foo

这实际上是否有任何意义,

{ println("Foo") }

？

是否可以编写一个"asInstanceOfOption"方法来执行以下(伪造)代码的意图？

def asInstanceOfOption[T](o: Any): Option[T] =
   if (o.isInstanceOf[T]) Some(o.asInstanceOf[T]) else None 

我希望能够根据具体类可能具有的各种属性从特征组装域对象.当我的对象是可变的时,这非常简单.例如:

trait HasHitPoints { var hitPoints: Int = 100 }
trait HasBearing { var bearing: Double = 0 }

class Ship extends HasHitPoints with HasBearing
class Base extends HasHitPoints

val entities = new Ship :: new Base :: Nil
entities.collect { case h: HasHitPoints => h.hitPoints += 10 }

特别是,我可以在HasHitPoints不知道具体类型的情况下以多态方式读取或更新任何实例.

使用不可变对象实现此操作的最佳方法是什么？如果我很高兴只阅读属性,那么我可以做类似的事情:

trait HasHitPoints { val hitPoints: Int }
trait HasBearing { val bearing: Double }

case class Ship(hitPoints: Int, bearing: Double) extends HasHitPoints with HasBearing
case class Base(hitPoints: …

在Scala中,有什么用

trait A <: B

意思？它和它一样吗？

trait A extends B

？

编辑添加:我熟悉类型参数的语法,以及<:在该上下文中的含义.但是,在上面的例子中,我认为这A是被声明的特征的名称,而不是类型参数.

为什么此代码无法编译,但在取消注释指示的行时成功编译？(我每晚都使用Scala 2.8).似乎显式调用string2Wrapper允许从该点隐式使用它.

class A {
  import Implicits.string2Wrapper
  def foo() {
     //string2Wrapper("A") ==> "B" // <-- uncomment
  } 
  def bar() {
    "A" ==> "B"
    "B" ==> "C"
    "C" ==> "D"
  }
  object Implicits {
    implicit def string2Wrapper(s: String) = new Wrapper(s)
    class Wrapper(s: String) {
      def ==>(s2: String) {}
    }
  }
}

编辑:感谢目前为止的答案,其中包括指向Martin Odersky评论的指针,

"没有显式结果类型的隐式转换只能在自己定义的文本中可见.这样,我们就避免了循环引用错误."

我仍然有兴趣找出1)"循环参考错误"的危险是什么？,2)为什么显式调用有什么不同？

关于什么时候你需要_一个方法来使用它作为一个函数,我对规则有点不稳定.例如,为什么以下的Foo's和Nil's 之间存在差异::？

def square(n: Int) = n * n  
object Foo { def ::(f: Int => Int) = f(42) }

// ...

scala> Foo.::(square)
res2: Int = 1764

scala> Nil.::(square) 
<console>:6: error: missing arguments for method square in object $iw;
follow this method with `_' if you want to treat it as a partially applied function
   Nil.::(square)
          ^
scala> Nil.::(square _) 
res3: List[(Int) => Int] = List(<function1>)

我正在尝试编写一个特性(在Scala 2.8中),它可以混合到一个case类中,允许在运行时检查它的字段,以用于特定的调试目的.我想按照它们在源文件中声明的顺序返回它们,我想省略case类中的任何其他字段.例如:

trait CaseClassReflector extends Product {

  def getFields: List[(String, Any)] = {
    var fieldValueToName: Map[Any, String] = Map()
    for (field <- getClass.getDeclaredFields) {
      field.setAccessible(true)
      fieldValueToName += (field.get(this) -> field.getName) 
    }
    productIterator.toList map { value => fieldValueToName(value) -> value }
  }

}

case class Colour(red: Int, green: Int, blue: Int) extends CaseClassReflector {
  val other: Int = 42
}

scala> val c = Colour(234, 123, 23)
c: Colour = Colour(234,123,23)

scala> val fields = c.getFields    
fields: List[(String, Any)] = List((red,234), …

我听过有人说(尽管我不记得具体是谁)每行代码的错误数量大致不变,无论使用何种语言.什么是支持这一点的研究？

编辑补充:我没有访问它,但显然,作者提出 "提出这样的问题每行代码(LOC)错误的数量是否是用不同的编程语言或程序不一样."