小编Dav*_*les的帖子

Subversion商店考虑转向Mercurial,试图提前弄清楚开发商的所有投诉是什么.这里有一个相当常见的用例,我看不懂如何处理.

1. 我正在研究一些较大的功能,而且我的代码中有很大一部分 - 或者可能是代码的几个重要部分 - 整个车库地板都是碎片,完全不适合签入,甚至可能不编译.
2. 一个紧急的错误修正请求进来.修复很好,本地,并没有触及我一直在努力的任何代码.
3. 我在我的工作副本中修复了.

怎么办？

我看过" Mercurial cherry pick for commit for commit "和" mercurial中的最佳实践:分支与克隆,以及部分合并？ ",所有建议似乎都是不同复杂程度的扩展,从Record和Shelve到Queues.

事实上,显然没有任何核心功能,这让我怀疑在某种意义上这种工作方式是做错了.这个用例的类似Mercurial的解决方案是什么样的？

编辑补充: git的,相比之下,似乎专为这个工作流程:git add修正错误的文件,没有git add任何东西(或者git reset HEAD你可能已经添加任何东西), git commit.

我刚刚对我的Rails Engine项目进行了新的检查,当bundle install我rails -v在其根目录中调用(之后)时,我得到一个LoadErrorRails似乎正在寻找我正在尝试构建的gem /引擎:

my-engine dmoles$ rails -v
/Users/dmoles/.rvm/rubies/ruby-2.2.1/lib/ruby/site_ruby/2.2.0/rubygems/dependency.rb:315:in `to_specs': Could not find 'my-engine' (>= 0) among 117 total gem(s) (Gem::LoadError)
Checked in 'GEM_PATH=/Users/dmoles/.rvm/gems/ruby-2.2.1:/Users/dmoles/.rvm/gems/ruby-2.2.1@global', execute `gem env` for more information
    from /Users/dmoles/.rvm/rubies/ruby-2.2.1/lib/ruby/site_ruby/2.2.0/rubygems/dependency.rb:324:in `to_spec'
    from /Users/dmoles/.rvm/rubies/ruby-2.2.1/lib/ruby/site_ruby/2.2.0/rubygems/core_ext/kernel_gem.rb:64:in `gem'
    from /Users/dmoles/.rvm/gems/ruby-2.2.1/bin/rails:22:in `<main>'

gem env按照建议运行不再提供启示:

my-engine dmoles$ gem env
RubyGems Environment:
  - RUBYGEMS VERSION: 2.4.6
  - RUBY VERSION: 2.2.1 (2015-02-26 patchlevel 85) [x86_64-darwin14]
  - INSTALLATION DIRECTORY: /Users/dmoles/.rvm/gems/ruby-2.2.1
  - RUBY EXECUTABLE: /Users/dmoles/.rvm/rubies/ruby-2.2.1/bin/ruby
  - EXECUTABLE DIRECTORY: /Users/dmoles/.rvm/gems/ruby-2.2.1/bin
  - …

我有一个Backbone集合,如下所示:

var FooCollection = Backbone.Collection.extend({
    model:Foo,

    initialize: function (attributes, options) {
        this.barId = options.barId;
    }
});

var Foo = Backbone.Model.extend({});

当我尝试初始化它时,我在_prepareModel()函数中得到"未捕获的TypeError:undefined不是函数" Backbone.Collection.

糟糕的电话是在model = new this.model(attrs, options).

// Prepare a model or hash of attributes to be added to this collection.
_prepareModel: function(model, options) {
  options || (options = {});
  if (!(model instanceof Model)) {
    var attrs = model;
    options.collection = this;
    model = new this.model(attrs, options); // <-- BLOWS UP HERE
    if (!model._validate(model.attributes, options)) …

我有一个带有Grails前端的大型遗留Java应用程序,我正在用一个用Play编写的新程序替换Grails前端.遗留Java中的一些(Maven)模块依赖项会带来有问题/冲突的问题.在这一点上排除所有遗留Java依赖项并不是一个真正的选项,所以我想排除我不喜欢的传递依赖项.

在Grails中BuildConfig.groovy,我可以定义一个排除列表:

def some_bad_things = [
        [group: 'some-evil-group'],
        [name: 'some-evil-module-from-another-group'],
        [name: 'some-other-evil-module']
]

然后将它用于整个直接依赖项块:

dependencies {
    compile (
        [group: 'com.foo', name: 'foo-module1', version: '1.0'],
        // ... 20 or 30 modules ...
        [group: 'com.quux', name: 'quux-module42', version: '7.2'],
    ) {
        excludes some_bad_things
    }
}

Build.scala做同样的事情的语法并不明显.翻译实际的依赖关系非常简单......

val appDependencies = Seq(
    "com.foo" % "foo-module1" % "1.0" % "compile",
    // ... 20 or 30 modules ...
    "com.quux" % "quux-module42" % "7.2" % "compile"
)

......但排除不是; 看起来我必须单独排除所有内容:

val appDependencies = Seq(
    ("com.foo" …

Java中是否有库函数或众所周知的快速有效方法将角度标准化为+/-π - 例如,当添加两个角度时？

我现在得到的(基于这个答案)基本上是下面的代码......

private static final double TWO_PI = 2 * Math.PI;

double normalize(double theta) {
    double normalized = theta % TWO_PI;
    normalized = (normalized + TWO_PI) % TWO_PI;
    return normalized <= Math.PI ? normalized : normalized - TWO_PI;
}

...但它似乎有点复杂和性能方面我对模运算符并不感兴趣.(请注意,我不能保证theta不是一些相对较大的数字,所以我认为没有循环的纯加法/减法解决方案.我实际上并不知道手动循环可能与之比较%. )

是否有一个经过充分测试的优化库函数,我可以使用,或者更好的算法,或者这是否与它一样好？

我正在处理一些第三方库代码,涉及创建昂贵的对象并将其缓存在Map.现有的实现类似于

lock.lock()
try {
    Foo result = cache.get(key);
    if (result == null) {
        result = createFooExpensively(key);
        cache.put(key, result);
    }
    return result;
} finally {
    lock.unlock();
}

显然,当Foos不同的keys可以独立创建时,这不是最好的设计.

我目前的黑客是使用以下Map方法Futures:

lock.lock();
Future<Foo> future;
try {
    future = allFutures.get(key);
    if (future == null) {
        future = executorService.submit(new Callable<Foo>() {
            public Foo call() {
                return createFooExpensively(key);
            }
        });
        allFutures.put(key, future);
    }
} finally {
    lock.unlock();
}

try {
    return future.get();
} catch (InterruptedException e) …

我on_spray-can_1.1按照Spray的" 入门 "页面上的建议克隆了Spray模板项目(分支),并使用sbt-idea生成相应的IDEA项目.它建立得很好,但是当我打开我的build.sbt文件时,最后一行让IDEA不高兴:

seq(Revolver.settings: _*)

它不承认Revolver,并建议进口spray.revolver.RevolverPlugin.Revolver,这似乎是合理的.但是,当我这样做时,它仍然抱怨"表达式类型(Def.SettingsDefinition)必须符合SBT文件中的设置[_]".

显然,这不是一个真正的问题,或者IDEA的(外部)make会失败,和/或SBT会从命令行中抱怨.但为什么IDEA认为这是一个问题？最近版本的SBT有什么变化吗？

当我看到SBT 0.13.0源代码时,我注意到seq它已被弃用; 它说"在build.sbt文件中,可以删除此调用." 但是,如果我这样做,Revolver会停止工作("不是有效命令:重新启动").

FWIW,我在Scint 2.10.3上使用SBT 0.13.0,在Mint 14上使用IDEA 12.1.6.

给出以下案例类:

case class Foo(
    bar: Int,
    baz: Boolean,
    qux: Option[Int],
    quux: Option[Boolean],
    quuux: Option[Integer]
)

我希望如下:

for (f <- classOf[Foo].getDeclaredFields) {
    println(f.getGenericType)
}

产生类似的东西:

int
boolean
scala.Option<int>
scala.Option<boolean>
scala.Option<java.lang.Integer>

但相反,它产生:

int
boolean
scala.Option<java.lang.Object>
scala.Option<java.lang.Object>
scala.Option<java.lang.Integer>

为什么原语会从泛型中删除,而不是像普通字段那样被视为java.lang.Integer.TYPE和java.lang.Boolean.TYPE？

有没有办法从中检索原始类型参数classOf[Foo]？

在Scala成为一个参数apply()之前,是否有一种方法可以修改传递给单参数案例类构造函数/ 方法的参数val？例如

case class AbsVal private(aVal: Double)

object AbsVal {
    def apply(aVal: Double): AbsVal = AbsVal(Math.abs(aVal)) // doesn't compile
}

当然,这对于重载定义的模糊引用是失败的.我想也许我可以使用命名参数(以及构造函数vs的不同参数名称apply())来欺骗它,但这也不起作用.

当然,而不是apply()我可以拥有私有构造函数和工厂方法,但是不得不乱丢代码AbsVal.make(x)而烦人AbsVal(x).

在Scala中,+ (k -> v) 运算符on immutable.Map返回包含immutable.Map原始内容的新内容以及新的键/值对.同样,在C#中,ImmutableDictionary.add(k, v)返回一个新的,更新的ImmutableDictionary.

然而,在Swift中,Dictionary似乎只有变异updateValue(v, forKey: k)函数和变异[k:v]运算符.

我想也许我可以玩一些技巧flatten(),但没有运气:

let updated = [original, [newKey: newValue]].flatten()

抓住我

Cannot convert value of type '() -> FlattenCollection<[[String : AnyObject]]>' 
to specified type '[String : AnyObject]'

如何Dictionary从现有内容创建一个新的,修改过的不可变的？

更新:根据这个答案的说明,Swift字典是值类型,这个答案的可变版本,我想出了以下扩展运算符,但我对此并不感兴趣 - 似乎必须有一个更清洁的开箱即用的替代方案.

func + <K, V>(left: [K:V], right: [K:V]) -> [K:V] {
    var union = left
    for (k, v) in right …