小编Ala*_*ell的帖子

有人可以帮我理解这个/给我一些阅读材料吗？以下工作正常:

type F a b = Functor f => f a -> f b
fComp :: F b c -> F a b -> F a c
fComp f f' = f . f'

但是,如果我写fComp = (.),而类型检查器抱怨:

Couldn't match type ‘b0 -> f c’
              with ‘forall (f1 :: * -> *). Functor f1 => f1 b -> f1 c’

(这个具体的例子并不是特别有用;我只是想缩小研究镜头时出现的例子.)

是否有可能将proc风味的Proc转换为lambda风味的Proc？

有点惊讶,这不起作用,至少在1.9.2:

my_proc = proc {|x| x}
my_lambda = lambda &p
my_lambda.lambda? # => false!

我正在玩pure和liftA2(以及(<*>) = liftA2 id成为派生组合者)制定Applicative .

我可以想到一堆候选法则,但我不确定最小集合是什么.

1. f <$> pure x = pure (f x)
2. f <$> liftA2 g x y = liftA2 ((f .) . g) x y
3. liftA2 f (pure x) y = f x <$> y
4. liftA2 f x (pure y) = liftA2 (flip f) (pure y) x
5. liftA2 f (g <$> x) (h <$> y) = liftA2 (\x y -> f (g x) (h y)) x y
6. ...

我遇到了案例类令人费解的类型推理问题.这是一个最小的例子:

trait T[X]
case class Thing[A, B, X](a: A, f: A => B) extends T[X]

def hmm[X](t: T[X]) = t match {
  case Thing(a, f) => f("this really shouldn't typecheck")
}

斯卡拉决定a: Any和f: Any => Any,但是这是不恰当的; 他们真的应该有类型的a: SomeTypeA和f: SomeTypeA => SomeTypeB,其中SomeTypeA和SomeTypeB未知类型.

另一种说法是我认为假设的Thing.unapply方法看起来应该是这样的

def unapply[X](t: T[X]): Option[(A, A => B)] forSome { type A; type B } = {
  t match {
    case thing: Thing[_, _, X] …

有点边缘情况,但任何想法为什么&& =会这样做？我正在使用1.9.2.

obj = Object.new
obj.instance_eval {@bar &&= @bar} # => nil, expected
obj.instance_variables # => [], so obj has no @bar instance variable

obj.instance_eval {@bar = @bar && @bar} # ostensibly the same as @bar &&= @bar
obj.instance_variables # => [:@bar] # why would this version initialize @bar?

为了比较,|| =将实例变量初始化为nil,正如我所期望的那样:

obj = Object.new
obj.instance_eval {@foo ||= @foo}
obj.instance_variables # => [:@foo], where @foo is set to nil

谢谢!

我在Clojure中实现了一些开始的SICP代码时遇到了意外的NullPointerException.特别是,我想实现1.1.7节中的迭代平方根过程.

这是代码:

(defn square [x] (* x x))

(defn abs [x]
  (cond 
    (< x 0) (- x)
    :else x))

(defn average [x y]
  (/ (+ x y) 2))

(defn sqrt
  ([x] (sqrt 1.0 x))
  ([guess x]
    (letfn [(good-enough? [guess]
              (< (abs (- (square guess) x)) 0.001))
            (improve [guess]
              (average guess (/ x guess)))]
      (if (good-enough? guess)
        guess
        (recur (improve guess) x)))))

这适用于足够小的值,例如(sqrt 16).NullPointerException clojure.lang.Numbers.lt (Numbers.java:3693)任何大于约的输入都会出错(square 2718).

有任何想法吗？

使用整个回溯进行更新(前一个是我在repl中获得的):

位于sicp_in_clojure.chapter_one $ sqrt $ good_enough_QMARK ___ …

http://nginx.org/en/CHANGES-0.7

为什么nginx过滤客户端请求包含下划线的标头？对此有明显的解释吗？

我觉得这对谷歌来说很容易,但是我找不到它:从HTTP缓存的角度来看,是什么决定了两个请求是否相同？

我想一个要素就是他们的网址需要相同; 例如,重新排列(但不更改)查询字符串参数似乎会导致缓存未命中.据推测,他们需要有相同的Accept标题.还有什么可以确定是否可以从缓存提供请求？

我是Coq的新手，对销毁策略有一个快速的疑问。假设我有一个count函数可以计算自然数列表中给定自然数的出现次数：

Fixpoint count (v : nat) (xs : natlist) : nat :=
  match xs with
    | nil => 0
    | h :: t =>
      match beq_nat h v with
        | true => 1 + count v xs
        | false => count v xs
      end
  end.

我想证明以下定理：

Theorem count_cons : forall (n y : nat) (xs : natlist),
  count n (y :: xs) = count n xs + count n [y].

如果我证明n = 0的类似定理，我可以简单地将y破坏为0或S y'。对于一般情况，我想做的是将（beq_nat ny）销毁为true或false，但我似乎无法使其正常工作-我缺少一些Coq语法。

有任何想法吗？