小编Geo*_*rge的帖子

考虑

$ git merge-base <original-branch> <new-branch>

问题:是git merge-base可交换的吗？也就是说,上述命令是否产生与之相同的结果

$ git merge-base <new-branch> <original-branch>

我经常收到以下Dropbox错误.错误消息的提议修复了错误,但我正在试图弄清楚它对我的系统做了什么,也许是否存在根本原因.

无法监控整个Dropbox文件夹层次结构.请跑

echo fs.inotify.max_user_watches=100000 | sudo tee -a /etc/sysctl.conf; sudo sysctl -p` 

Run Code Online (Sandbox Code Playgroud)

并重新启动Dropbox以解决问题.

以下内容获取项目master分支的原始提交列表：

https://api.github.com/repos/<organization_name>/<repo_name/commits?page=0&per_page=30

问题 1：如何获得一个类似但特定的列表<branchname>？

问题 2：上面的提交列表不包括有关每次提交添加/删除的代码行的任何数据（即，非常粗略的生产力指标）。有没有办法在查询中获取这些数据？

假设我的光标在单词内word.使用vim-surround,键入序列ysiw*将替换word为*word*.

问题:我可以输入一个单独的序列来生成**word**(即,用于字粗体的公共降价方法)？这反对键入ysiw*两次,这感觉很麻烦.

我试图理解Var的 clojure 概念。

As far as I can tell, it's just a reference/pointer to a value. The "root value" of a Var can be thought of as the initial value that a Var points to on a thread. Moreover, I take it that -- behind the scenes -- every Var has an address to the position in memory it is pointing towards (even though languages like Java, Javascript don't give you access to that particular location, and perhaps …

设StringWrapper1和StringWrapper2是两个类型的包裹在一个字符串(即newtype StringWrapper1 = StringWrapper1 String和newtype StringWrapper2 = StringWrapper2).

现在假设我们试图从制作一个函数StringWrapper1来StringWrapper2.

funcWrapper :: StringWrapper1 -> StringWrapper2

一方面,我们希望明确表示我们传入此函数的内容是a StringWrapper1,因此我们不希望仅将其StringWrapper1视为类型的同义词String(这会导致错误,因为我自己的经验可以证明).另一方面,当从概念上构建函数时,我们仍然以某种方式思考Strings.我们想要做的是首先构建func哪个不是我们不断包装和解包类型:

func :: String -> String

然后,我们func用来构建funcWrapper:

funcWrapper :: StringWrapper1 -> StringWrapper2
funcWrapper (StringWrapper1 str) = StringWrapper2 (func str)

问题/疑问:这是惯用的吗？用a func和a 来复制每个函数似乎很尴尬funcWrapper.Haskell是否提供了其他一些我不知道的方法？或者我应该只使用类型同义词？

AFAIK,这是LISP方言的标志性特征:例如,假设我们启动了一个正在进行的LISP程序,该程序重复调用一些名为的函数func.然后我们可以进入lisp REPL,更改定义func,然后在程序下次调用时,程序func的行为将被适当地改变为live.

我相信这个属性被称为后期绑定,虽然我不确定我是否正确.

后期绑定的好处是它允许您在程序仍在运行时重构甚至完全更改程序.这在生物学上类似于这样一个事实,即随着年龄的增长,我们体内的几乎每个细胞都会在足够长的时间范围内被新的细胞取代(当然我们从未注意到).它可以使系统非常灵活.

问题:在Haskell中有什么方法可以做类似的事情吗？如果Haskell不允许这样做,那么它是否有充分的理由(即,是否需要进行更大的权衡才能使其变得有价值)？

目前，我在一个具有文件的目录中libshared-object.so（名称出于一般性而更改）。

当我跑步

$ objdump -p libshared-object.so

我收到以下输出：

libshared-object.so:     file format elf64-x86-64

Program Header:
        LOAD off    0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**21
                 filesz 0x00000000000828ee memsz 0x00000000000828ee flags r-x
        LOAD off    0x0000000000083768 vaddr 0x0000000000283768 paddr 0x0000000000283768 align 2**21
                 filesz 0x00000000000048e0 memsz 0x0000000000004af0 flags rw-
 DYNAMIC off    0x0000000000084af0 vaddr 0x0000000000284af0 paddr 0x0000000000284af0 align 2**3
                 filesz 0x00000000000002a0 memsz 0x00000000000002a0 flags rw-
        NOTE off    0x00000000000001c8 vaddr 0x00000000000001c8 paddr 0x00000000000001c8 align 2**2
                 filesz 0x0000000000000024 memsz 0x0000000000000024 flags r--
EH_FRAME off    0x0000000000072c6c vaddr 0x0000000000072c6c …

类型签名$如下:

($) :: (a -> b) -> a -> b

因此,如果plus1 n = n + 1,那么我们就有了

> ($) plus1 1
2

但那为什么呢

> ($ 1) plus1
2

还有？表单($ 1) plus1似乎违反了类型签名$.

例如CIntvs Int#vs CInt#？之间的关系是什么？

例如,如果我调用一个返回a的外部函数,它CInt是不是已经CInt#构造了(也就是说,它是int堆栈上的raw ,而不是指向包含a的堆上的东西的指针int)？

在那种情况下,CInt和之间会有什么区别Int#？

如果我试图竭力维持的性能每一点,我可以,使用了哪一种CInt,并Int#和CInt#？