小编Gre*_*idt的帖子

究竟是什么val a: A = _初始化了一个值？这是一个打字的空吗？谢谢.

说我Array[Int]喜欢

val array = Array( 1, 2, 3 )

现在我想在数组中添加一个元素,比如值4,如下例所示:

val array2 = array + 4     // will not compile

我当然可以System.arraycopy()自己使用并执行此操作,但必须有一个Scala库函数,我根本找不到.感谢您的任何指示!

笔记:

1. 我知道我可以附加另一个元素数组,如下面一行,但这似乎太圆了:

   val array2b = array ++ Array( 4 )     // this works
   

   Run Code Online (Sandbox Code Playgroud)

2. 我知道List vs Array的优点和缺点,在这里我出于各种原因特别感兴趣扩展Array.

编辑1

感谢指向:+操作员方法的答案.这就是我想要的.不幸的是,它比使用自定义append()方法实现慢得多arraycopy- 大约慢两到三倍.查看实现SeqLike[],创建构建器,然后将数组添加到其中,然后通过构建器完成追加,然后呈现构建器.对阵列来说不是一个好的实现.我做了一个比较两种方法的快速基准测试,查看十个周期中最快的时间.将一个项目的1000万次重复附加到某个类的8个元素数组实例Foo需要3.1秒:+和1.7秒,使用一个简单的append()方法,使用System.arraycopy();在8个元素的Long元素上执行1000万个单项追加重复2.1用:+简单的append()方法得秒和0.78秒.想知道这是否无法在具有自定义实现的库中修复Array？

编辑2

为了它的价值,我提交了一张票:https: //issues.scala-lang.org/browse/SI-5017

请考虑以下代码段:

 object A {
     val b = c
     val c = "foo"
 }
 println( A.b )   // prints "null"

作为更大程序的一部分,这将导致运行时失败.编译器显然允许从'b'到(未初始化)'c'的前向引用,但是'b'留下c的原始空值.为什么允许这样做？是否有可以从此功能中受益的编程方案？

将代码更改为直接序列并且行为更改:

 val b = c
 val c = "foo"
 println( b )   // prints "foo"

为什么行为不同？为什么这甚至有效？谢谢.

更新1:

问题出现了我如何运行第二个例子.我简化了设置并使用最新的Scala插件在IntelliJ IDEA 10.5.2中使用Scala 2.9.0.1编译它.这是确切的代码,在一个新创建的和其他空项目中,我用它来测试它,它在这种环境中编译并运行良好:

 package test
 object Main { 
    def main( args: Array[String] ) {
       val b = c
       val c = "foo"
       println( b )   // prints "foo"
    }
 }

对于它的价值,IDEA还认为(当我点击"通过"对val b = c中的'c'的引用时)我指的是(c)的(后面)声明.

假设我有一个函数检查某个操作是否适用于A的实例,如果是,则返回B或None的实例:

   def checker[A,B]( a: A ) : Option[B] = ...

现在我想形成一个包含B的所有有效实例的新集合,删除None值.以下代码似乎可以完成这项工作,但肯定有更好的方法:

   val as = List[A]( a1, a2, a3, ... )
   val bs = 
     as
     .map( (a) => checker(a) )    // List[A] => List[Option[B]]
     .filter( _.isDefined )       // List[Option[B]] => List[Option[B]]
     .map( _.get )                // List[Option[B]] => List[B]

谢谢!

在Scala 2.9.1中,我得到以下行为:

class Foo {
   case class X()
   object X            // this compiles

   def bar() {
      object Y         // this compiles
      case class Y()

      case class Z()
      object Z         // won't compile (see below)
   }
}

编译器抱怨Object Z:错误:Z已经被定义为(编译器生成的)案例类伴随对象Z.

在案例类定义之后,如果它们在函数定义中,则看起来不允许为案例类定义伴随对象.这是编译器错误还是故意的？如果是后者,为什么？

考虑Scala中的以下基类和派生类:

    abstract class Base( val x : String )

    final class Derived( x : String ) extends Base( "Base's " + x )
    {
        override def toString = x
    }

这里,Derived类参数的标识符'x'覆盖Base类的字段,因此调用toString如下:

    println( new Derived( "string" ).toString )

返回Derived值并给出结果"string".

因此,对'x'参数的引用会提示编译器自动在Derived上生成一个字段,该字段在调用toString时提供.这通常非常方便,但会导致字段的复制(我现在将字段存储在Base和Derived上),这可能是不合需要的.为了避免这种复制,我可以将Derived类参数从'x'重命名为其他内容,例如'_x':

    abstract class Base( val x : String )

    final class Derived( _x : String ) extends Base( "Base's " + _x )
    {
        override def toString = x
    }

现在调用toString返回"Base的字符串",这就是我想要的.不幸的是,代码现在看起来有些难看,使用命名参数来初始化类也变得不那么优雅了:

    new Derived( _x = "string" ) 

还存在忘记给派生类的初始化参数赋予不同名称并且无意中引用错误字段的风险(因为Base类实际上可能保持不同的值,所以不合需要).

有没有更好的办法？

编辑1:为了澄清,我真的只想要Base值; 导出的只是初始化基类字段所必需的.该示例仅引用它们来说明随后出现的问题. …

我可以在Scala中使用哪些技术来处理长类型参数列表？

我正在研究一个用于运行具有不同模拟环境的各种类型游戏的小框架.我试图保持框架的某些部分相对通用,所以我将各种类型作为类型参数引入,例如环境状态,游戏结果等.

它在功能上都运行良好,我确实获得了类型安全但通用框架的预期好处.但是类型签名已经发展到了使代码难以阅读和重构的程度,它变得非常繁琐.顶级模拟器的签名有八个类型参数,许多主要类型有三到五个.单个编译器类型错误,因为它们列出类或函数参数的类型(当然也是类型参数化)似乎经常运行到一百行.

偶尔,但很少,我可以省略类型参数,例如在构造函数上.但在大多数情况下,至少有一种类型不会被推断,所以我最终不得不插入整个类型的签名.

显然这不是理想的,我正在寻找解决这个问题的方法.任何意见,将不胜感激!

给定具有N个独立值和1个从属值的(N + 1)维实值向量的集合,我想计算1度(线性),2(二次)或更高的多项式,其提供合理的拟合(例如,由最小二乘误差确定).换句话说,当应用于集合的元素时,多项式应该将每个的独立值映射到相关的从属值(具有一些合理的误差范围).

我希望自变量的维数在2..8范围内,并且可以处理20..200个元素的集合.我希望以毫秒而不是秒为单位拟合多项式.:-)

我很快找到了一维数据的多项式回归算法,但我还没有能够提出任何实用的多维数据.我主要对算法描述或源代码感兴趣.有什么指针吗？

我是一个相对Scala初学者,并希望得到一些关于如何继续实现的建议,看起来可以通过返回Option或PartialFunction的函数来完成.我已经阅读了我能找到的所有相关帖子(参见问题的底部),但这些似乎涉及使用PartialFunction或将其中一个转换为另一个的技术细节; 我正在寻找类型的答案"如果情况是X,Y,Z,那么使用A其他B,但也考虑C".

我的示例用例是使用路径查找器库在位置之间进行路径搜索.假设位置是类型L,路径是类型P,所需的路径搜索结果是Iterable[P].补丁搜索结果应该通过询问所有路径查找器(像Google地图这些可能是自行车,汽车,步行,地铁等等)的路径建议来组装,这些建议可能会或可能不会针对特定的开始/定义结束位置对.

似乎有两种方法可以解决这个问题:

(a)将路径查找器定义为f: (L,L) => Option[P],然后通过类似的方式获得结果finders.map( _.apply(l1,l2) ).filter( _.isDefined ).map( _.get )

(b)将路径查找器定义为f: PartialFunction[(L,L),P] and then get the result via something likefinders.filter(_.isDefined((l1,l2))).map(_.apply((l1,l2)))`

似乎使用函数返回Option[P]将避免对结果进行双重评估,因此对于昂贵的计算,除非有人缓存结果,否则这可能是优选的.似乎使用Option一个可以有一个任意输入签名,而PartialFunction期望一个参数.但是我特别感兴趣的是听到有实际经验的人关于不那么直接,更大的"更大图片"考虑因素,例如与Scala库的交互.使用a PartialFunction会在提供可能以其他方式获得回报的集合API的某些方法方面具有显着优势吗？这样的代码通常会更简洁吗？

相关但不同的问题:

• 反向PartialFunction的提升方法
• PartialFunction设计效率低下吗？
• 如何将X => Option [R]转换为PartialFunction [X,R]
• 有没有更好的方法在Scala中提升PartialFunction？
• 在PartDefine的定义和应用中都会出现代价高昂的计算

当需要包含全零的数组[双精度]时,使用是否安全

    val allZeros = new Array[Double](10)
    val whatever = allZeros( 5 )     // guaranteed to be 0.0, not null?
    assert( whatever == 0.0 )        // succeeds

或者我应该坚持

    val allZeros = Array.fill[Double](10)( 0.0 )

我知道第一个版本有效,但这是语言的保证,即它是否总是安全的？Double理论上也可以初始化null(尽管如此,考虑到它,作为一名语言设计师,我宁愿不做出那种改变:-).