小编Eug*_*ota的帖子

我一直在使用TortoiseSVN,svn和subclipse,我认为我理解基础知识,但有一件事一直困扰着我:合并引入了不需要的代码.这是步骤.

trunk/test.txt@r2.使用"A"和返回创建了一个测试文件:

A
[EOF]

branches/TRY-XX-Foo/test.txt@r3.分支trunk到TRY-XX-Foo:

A
[EOF]

branches/TRY-XX-Foo/test.txt@r4.做出了不必要的改变TRY-XX-Foo并承诺:

A
B (unwanted change)
[EOF]

branches/TRY-XX-Foo/test.txt@r5.做了一个重要的错误修复TRY-XX-Foo并承诺:

A
B (unwanted change)
C (important bug fix)
[EOF]

现在,我想只将重要的bug修复合并到trunk.所以,我运行merge进行修订4:5.我在工作目录中的最终结果是冲突.

trunk/test.txt:

A
<<<<<<< .working
=======
B (unwanted change)
C (important bug fix)
>>>>>>> .merge-right.r5
[EOF]

违背我的意愿,Subversion现在已将"不需要的更改"包含在中继代码中,我需要手动清除它们.当在分支中进行多个连续更改时,是否有一种方法只合并指定的修订版本？

问题的一部分是B(unwated change)包含在.merge-right中,我无法区分它来自哪个版本.我通常使用TortoiseMerge,这是它的外观.

假设您有一个3维对象,以某种常见文件格式表示为3d网格.你将如何设计一种算法将网格分解为一个或多个2d'网' - 也就是说,可以剪切和折叠以创建原始3d对象的二维表示.

除此之外,该算法还需要考虑:

• 对任何给定对象进行多次可能的分解
• 处理将网格装配到固定尺寸的画布(纸张).
• 识别网中的两个面板何时重叠(因此无效).
• 由于重叠或页面大小限制,如果网格无法表示为单个网格,则将网格分成多个网络.
• 在适当的位置生成制表符,用于附加相邻的面.

明显的退化情况就是每面创建一个网,边缘有一半.这显然不是理想的:理想的情况是单个连续网.复杂形状的现实很可能在中间.

我意识到找到最佳网络(最少网络/最少页面)可能计算成本很高,但是找到"足够好"的网络的良好启发式就足够了.

给定一系列实现解析器组合器的对象,如何组合解析器？由于Parsers.Parser是一个内部类,并且在Scala 内部类中绑定到外部对象,故事变得有点复杂.

这是一个尝试组合来自不同对象的两个解析器的示例.

import scala.util.parsing.combinator._

class BinaryParser extends JavaTokenParsers {
  def anyrep: Parser[Any] = rep(any)
  def any: Parser[Any] = zero | one
  def zero: Parser[Any] = "0"
  def one: Parser[Any] = "1"
}

object LongChainParser extends BinaryParser {
  def parser1: Parser[Any] = zero~zero~one~one
}

object ShortChainParser extends BinaryParser {
  def parser2: Parser[Any] = zero~zero
}

object ExampleParser extends BinaryParser {
  def parser: Parser[Any] = (LongChainParser.parser1
    ||| ShortChainParser.parser2) ~ anyrep

  def main(args: Array[String]) {
    println(parseAll(parser, args(0) )) …

如何在不创建任何新集合的情况下做到这一点 有比这更好的东西吗？

val m = scala.collection.mutable.Map[String, Long]("1" -> 1, "2" -> 2, "3" -> 3, "4" -> 4)
m.foreach(t => if (t._2 % 2 == 0) m.remove(t._1))
println(m)

PS中的Scala 2.8

我想在我的Iterables上打电话'包含':-)

假设我们只有局部范围的隐式参数查找:

trait CanFoo[A] {
  def foos(x: A): String
}

object Def {
  implicit object ImportIntFoo extends CanFoo[Int] {
    def foos(x: Int) = "ImportIntFoo:" + x.toString
  }
}

object Main {
  def test(): String = {
    implicit object LocalIntFoo extends CanFoo[Int] {
      def foos(x: Int) = "LocalIntFoo:" + x.toString
    }
    import Def._

    foo(1)
  }

  def foo[A:CanFoo](x: A): String = implicitly[CanFoo[A]].foos(x)
}

在上面的代码中,LocalIntFoo胜过ImportedIntFoo.有人可以使用"静态重载决策规则(§6.26.3)"来解释它是如何被认为更具体的吗？

编辑:

名称绑定优先级是一个引人注目的参数,但有几个问题尚未解决.首先,Scala语言参考说:

如果有几个符合条件的参数与隐式参数的类型匹配,则将使用静态重载决策的规则(第6.26.3节)选择最具体的参数.

其次,名称绑定优先级是关于在范围内有多个变量/方法/对象的情况下解析x特定成员的已知标识符.并且没有相同的名称.pkg.A.B.xxImportIntFooLocalIntFoo

第三,我可以证明单独的 …

我将很快开始为我现在的雇主维护一个Eclipse RCP应用程序.
您对此平台有何经验？什么是专业人士,有什么缺点,我应该注意哪些警告？
另外,您可以推荐哪些阅读材料(书籍,教程)？我在网上找到的大多数教程都已过时,有哪些更好的教程更新？
我开始阅读 Eclipse Rich Client Platform:设计,编码和打包Java(TM)应用程序, 但由于它也已经过时,我在开始时就陷入了困境,这本书实际上似乎更像是一系列的食谱做一些关于这个主题的真实书籍(它没有很好地解释核心概念).
那么,您能告诉我有关使用Eclipse RCP开发应用程序的好方面和坏方面,以及您的阅读建议是什么？

Java API返回一个java.util.Map<java.lang.String,java.lang.Boolean>;.我想把它变成一个Map[String,Boolean]

所以想象我们有:

var scalaMap : Map[String,Boolean] = Map.empty
val javaMap = new JavaClass().map()   // Returns java.util.Map<java.lang.String,java.lang.Boolean>

你做不到Map.empty ++ javaMap,因为++方法不了解Java地图.我试过了:

scalaMap = Map.empty ++ new collection.jcl.MapWrapper[String,Boolean] {
    override def underlying = javaMap
}

和:

scalaMap = Map.empty ++ new collection.jcl.MapWrapper[java.lang.String,java.lang.Boolean] {
    override def underlying = javaMap
  }

这些都无法编译,因为泛型 - java.lang.String与scala String不同.

有没有一种好方法可以做到这一点,而不是手动复制地图？

编辑:谢谢,所有好的答案,我从他们所有人那里学到了很多东西.但是,我在这里发布一个比我实际拥有的更简单的问题犯了一个错误.所以,如果你允许我,我会概括一个问题 - API实际返回的是什么

java.util.Map<java.lang.String, java.util.Map<SomeJavaEnum,java.lang.String>>

我需要将其移动到Map [String,Map [SomeJavaEnum,String]]

它似乎不太复杂,但它增加了额外级别的类型擦除,我发现将其移动到Scala地图的唯一方法是深度复制它(使用下面建议的一些技术) .任何提示？我通过为我的确切类型定义一个隐式转换来解决我的问题,所以至少丑陋隐藏在它自己的特性中,但仍然感觉有点笨拙的深层复制.

有没有办法在O(1)时间内将可变映射转换(换行)为不可变(也就是说,不是通过复制值,而是类似于在JavaConversions中完成的操作)

在我的一个项目中,一个常见的用例不断涌现.在某些时候,我有一个某种类型的排序集合(List,Seq等......无所谓)和这个集合的一个元素.我想要做的是交换给定元素与它的后续元素(如果此元素存在)或在某些时候与前面的元素交换.

我很清楚使用过程编程技术实现这一目标的方法.我的问题是通过函数式编程(在Scala中)解决问题的好方法是什么？

谢谢大家的答案.我接受了我自己最了解的那个.由于我不是一名功能性程序员(但是),我很难确定哪个答案真的是最好的.在我看来,它们都非常好.