小编Per*_*ids的帖子

什么是等效的mercurial命令(或工作流程)

git reset --mixed HEAD^

要么

git reset --soft  HEAD^

即我希望保持工作树完整,但让存储库回到最后一次提交之前的状态.令人惊讶的是,我没有在stackoverflow或google上找到任何有用的东西.

请注意,我不能使用

hg rollback

因为我在最后一次提交后使用HistEdit完成了一些历史记录重写.

补充说明: 经过一些重新定位和历史编辑后,我最终得到了A < - B < - C. 然后我用HistEdit将B和C压在一起,得到A < - C'.现在我想拆分提交C'(我​​在B中提交了错误的文件).我认为最简单的方法是将存储库恢复到状态A(技术上从未在存储库中存在,因为所有的重新定位和历史编辑事先)和工作树到状态C'然后做两个提交.

是否有一个类似于Haskell'let'表达式的Python,它可以让我写出如下内容:

list2 = [let (name,size)=lookup(productId) in (barcode(productId),metric(size)) 
            for productId in list]

如果没有,最可读的替代方案是什么？

添加以澄清let语法:

x = let (name,size)=lookup(productId) in (barcode(productId),metric(size))

相当于

(name,size) = lookup(productId)
x = (barcode(productId),metric(size))

但是,第二个版本与列表推导不太相配.

我需要一种方法来读取Popen创建的流中所有当前可用的字符,或者找出缓冲区中剩余的字符数.

Backround:我想用Python远程控制交互式应用程序.到目前为止,我使用Popen创建了一个新的子进程:

process=subprocess.Popen(["python"],shell=True,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE, cwd=workingDir)

(我不是真正启动python,但实际的交互式界面是类似的.)目前我读取1个字节,直到我检测到进程已到达命令提示符:

output = ""
while output[-6:]!="SCIP> ":
    output += process.stdout.read(1)
    sys.stdout.write(output[-1])
return output

然后我开始一个冗长的计算process.stdin.write("command\n").我的问题是,我无法检查计算是否已经完成,因为我无法检查流中的最后一个字符是否是提示.read()或者read(n)阻止我的线程,直到它到达EOF,它永远不会,因为交互式程序在被告知之前不会结束.以上述循环方式查找提示也不起作用,因为提示只会在计算后发生.

理想的解决方案将允许我从流中读取所有可用字符,并立即返回空字符串,如果没有任何内容可读.

Scala允许关闭

def newCounter = {
  var a=0
  () => {a+=1;a}
}

它定义了在每次调用返回一个新的独立的反函数开始一个函数1:

scala> val counter1 = newCounter
counter1: () => Int = <function0>

scala> counter1()
res0: Int = 1

scala> counter1()
res1: Int = 2

scala> val counter2 = newCounter
counter2: () => Int = <function0>

scala> counter2()
res2: Int = 1

scala> counter1()
res3: Int = 3

这是非常令人印象深刻的,因为通常a会在newCounter的堆栈帧上代表内存地址.我刚刚阅读了"Scala编程"的封闭章节,并且在此事上只有以下内容(第155页):

Scala编译器在这种情况下重新排列事物,以便捕获的参数在堆上而不是堆栈中存在,因此可以比创建它的方法调用更长.这种重新安排都是自动完成的,因此您不必担心.

任何人都可以详细说明它如何在字节码级别上工作？访问是否类似于具有所有相关同步和性能影响的类的成员变量？

我有一个数组,我想从中删除一些元素.我无法使用Array.prototype.filter(),因为我想在适当的位置修改数组(因为它节省了内存分配,对我来说更重要的是,在我的用例中使代码更简单).是否存在filter我可以使用的就地替代方案,可能类似于如何Array.prototype.forEach()用作就地变体Array.prototype.map()？

编辑:请求时的最小示例:

function someCallback(array) {
  // do some stuff
  array.filterInPlace(function(elem) {
    var result = /* some logic */
    return result;
  })
  // do some more stuff
}

我正试着在Rust中度过生命,并问自己,他们是否"只是"一种安全措施(以及在错误的情况下沟通如何确保安全性的方式)或者是否存在不同选择的情况生命周期实际上改变了程序的运行方式,即生命周期是否与编译的程序产生语义差异.

并以"寿命"我指的是所有讨厌的小'a,'b,'static标志我们包括使借检查开心.当然,写作

{
    let foo = File::open("foo.txt")?;
} 
foo.write_all(b"bar");

代替

let foo = File::open("foo.txt")?;
foo.write_all(b"bar");

将在写入发生之前关闭文件描述符,即使我们之后可以访问foo,但是这种范围和析构函数调用也会在C++中发生.

也许我的Google Foo不够强大,但我无法找到有关何时缓存中的Docker镜像无效的明确列表.具体来说,我至少在这些场景中感兴趣:

• 由于mtime更改与校验和更改而导致失效.哪个适用于？它可以处理不同的源路径(例如,不同目录中存储库的克隆)吗？
• 因更新的基本映像而失效.在这一点上,例如Debian的(安全)更新会向我泡泡吗？
• 是否存在任何显式API,持续集成工具可以使用它来告诉Docker哪些缓存图像可以重用,哪些不可以(例如因为a wget foo.com/latest.gz)？

在更实际的术语中:我应该为向量中的索引,数组的长度等使用什么整数数据类型？

关于这个主题的讨论有很多关于1.0之前的Rust在互联网上流传的问题,我找不到最终决定的权威答案.

我正在学习一些解决Matasano Crypto挑战的Rust,并坚持使用Ceasar密码("单字节xor")作为迭代器.我的函数应该是这样的:

fn ceaser_cipher_iter(data: &Vec<u8>, key :u8) -> SomeType {
    data.iter().map(move |&p| p^key)
}

替换SomeType为(),编译器告诉我它所期望的类型:core::iter::Map<core::slice::Iter<'_, u8>, [closure src/main.rs:59:21: 59:31]>.一些撞头后,我发现我可以用std::slice::Iter<u8>了core::slice::Iter<'_, u8>,这让关闭.据我了解,我的天真实验使用

fn ceaser_cipher_iter(data: &Vec<u8>, key :u8) -> Map<std::slice::Iter<u8>, fn(&u8)->u8 > {
    data.iter().map(move |&p| p^key)
}

无法工作,因为Rust需要知道确切的闭包类型来为闭包分配内存(key必须通过将moved存入闭包来存储).我试图按照建议使用一个Box代替:

fn ceaser_cipher_iter(data: &Vec<u8>, key :u8) -> Map<std::slice::Iter<u8>, Box<Fn(&u8)->u8> > {
    data.iter().map(Box::new(move |&p| p^key))
}

但是afaict map不支持它:

src/main.rs:59:17: 59:47 error: the trait `core::ops::FnMut<(&u8,)>` is not implemented …

许多迭代器实现了Clone特征,但它们都没有实现Copy特征.至少对于简单的迭代器一样std:slice::Iter,在Clone执行看起来像一个的memcpy无论如何,所以为什么不Copy还实施？