小编ccQ*_*ein的帖子

我有一个与浏览器如何知道站点是否支持 HTTP/2？。我想知道浏览器如何知道网站支持http3。

我正在使用 safari 并打开了 http3 支持。然后我去https://cloudflare-quic.com，协议是h3-29。我认为我的 safari 使用 h3 协议探索这个网站。它是怎么知道的呢？

我想编写一个直接打开文件的功能。就像Python代码一样：

os.system("ls")

例如，当我使用此功能（fun_open“/path/to/file”）时，系统将使用默认应用程序打开文件。如果文件是 .txt，请使用 textedit 打开它。

怎样制作呢？

----更新 9/24/2015-----

我的代码是：

(defun open_by_system (dir)
  (sb-ext:run-program "/usr/bin/open" (list "-a" "Preview" dir)))

我用它：

CL-USER> (open_by_system "~/Desktop/ML.pdf")
#<SB-IMPL::PROCESS :EXITED 1>

没有其他事情发生

今晚我在读cl-fad/load.lisp代码，发现表达式或字符串前面有符号#+:和。#-:

这些符号的含义是什么？

我最近使用过cl-ppcre软件包，我对它们如何优化此软件包感到非常好奇，因为我想学习优化常见的Lisp。我注意到他们在声明表达式中经常使用Sharpsign Dot，就像这里。优化设置在此处。

他们为什么这样写？有什么好处吗？还是有一些规则要做？

更新：我跑步

(defvar *b* '(optimize speed))
(pprint (macroexpand-1 '(declaim *b*)))
(pprint (macroexpand-1 '(declaim #.*b*))) ;; => this one is right

那么，#.在宏调用之前，eval值会否？像它一样先评估该值，然后将其替换为宏参数。

几周前，SBCL 更新了 2.0.2 并带来了 Block 编译功能。我已经阅读了这篇文章以了解它是什么。

我有一个问题，(declaim (inline 'some-function))和 Block 编译有什么区别？块编译是由编译器自动进行的吗？

谢谢。

家伙.

今天我想编写sigma宏来计算灵活表达式输入的总和.

下面的代码是我今天下午写的.但它不符合我的目的.

(defmacro sigma (exp ll)
  `(+ ,@(loop for i in ll collect
             (progn (setf (elt exp 1) i)
                    (print exp)
                    exp)))
  )

>>(pprint (macroexpand-1 '(sigma (+ 1 2) (2 3 4))))
>>(+ 2 2) 
  (+ 3 2) 
  (+ 4 2) 
  (+ (+ 4 2) (+ 4 2) (+ 4 2))

我希望它有效,(+ (+ 2 2) (+ 3 2) (+ 4 2))但loop collect给我一个奇怪的答案.

它为什么这样工作？我有一些方法可以解决这个问题吗？

我检查doc中的Index trait并找到index()is的返回类型&T.

然后我写这个函数来从vector获取值:

fn get_value_test(a: usize, v: &Vec<i32>) -> i32 {
    v[a]
}

我的问题是:为什么v[a]是i32不过&i32？因为i32 ...have a known size at compile time are stored entirely on the stack, so copies of the actual values are quick to make？(从这里)

看起来Rust在这种情况下有隐藏规则转换类型？

我只是在我的Common Lisp代码遇到异常情况时，我想测试locally和declare：

(defvar test-out 2) ;; make a dynamic variable

;; function below just simply re-write from locally doc
(defun test (out)
  (declare (special out))
  (let ((out 1))
    (print out) ;; => 1
    (print (locally (declare (special out)) out)))) ;; => 2

;; when argument has same name as outside dynamic variable
(defun test1 (test-out)
  (declare (special test-out))
  (let ((test-out 1))
    (print test-out) ;; => 1
    (print (locally (declare (special test-out)) test-out)))) ;; => also 1 …

我在一个文件中写了一个宏和一个函数，如下所示：

(defun test ()
  (let ((x '(1 2 3)))
    (macro-test (x real-b)
      (print (+ 1 (car real-b))))))

(defmacro macro-test ((a b) &body body)
  `(do ((,b ,a (cdr ,b)))
       ((not ,b))
     ,@body))

然后我在 repl 中加载这个文件并运行(test). 我收到此错误：

The variable REAL-B is unbound.

然而，当我defmacro 之前 把defun. 一切安好。

我对常见的 lisp 编译顺序感到困惑。我知道如果defmacro在里面使用一些函数，那些函数应该(eval-when (:compile-toplevel :load-toplevel :execute))，否则编译会失败。

但是，如果编译时宏定义和函数定义相同，那么顺序就是问题，对吗？宏应位于使用它们之前的位置（如果我创建两个函数，则顺序无关紧要）。我可以得到更多关于 SBCL 编译顺序的细节吗？它仅适用于 SBCL 吗？还是按照 Common Lisp 的标准？

谢谢！

我写了一个for循环来遍历Map，我希望这个函数在找到某个值时立即返回键（键和值都是Int类型）

var hs:Map[Int,Int] = Map(1 -> 1, 2 -> 2)
for ((k,v) <- hs) {
  if (v == 1)
    return k   
}

但是，scala 给我错误消息：

error: type mismatch;
 found   : Unit
 required: Int
  for ((k,v) <- hst)
             ^
one error found

然后我改为

var result = 0
for ((k, v) <- hst){
  if (v == 1)
    result = k
}
result

然后，效果很好。为什么第一个版本存在类型问题？

我正在ListNode用 Rust编写递归类型。我必须Box在结构中使用，并且我正在尝试编写一个循环来添加next ListNode. 但是，我想尝试使用除递归方法之外的指针。

#[derive(Debug)]
struct ListNode {
    val: i32,
    next: Option<Box<ListNode>>,
}

impl ListNode {
    fn new(i: i32) -> Self {
        ListNode { val: i, next: None }
    }

    fn add_l(&mut self, l: &Vec<i32>) {
        let mut p: *mut ListNode = self as *mut ListNode;
        for i in l {
            unsafe {
                (*p).next = Some(Box::new(ListNode::new(*i)));
                let temp_b = Box::from_raw(p);
                p = Box::into_raw(temp_b.next.wrap());
            };
        }
    }
}

fn main() {
    let mut a = …

我找到了通用 lisp 的所有类型说明符。还有就是list里面。但是list在 Common Lisp 中没有象数组那样声明的例子，(declare (array fixnum 10)).

那么，声明列表类型说明符的正确方法是什么？谢谢

我正在编写一个函数，该函数根据Map.Map参数中的 Map 是否为空而具有不同的操作

这是我的代码：

import qualified Data.Map.Lazy as Map

testF :: (Ord a, Num a) => Map.Map a a -> [a] -> [a]
testF empty _  = [1024]
testF _ []     = []
testF m (x:xs) = [x] ++ (testF m xs)

main = do
  let a = Map.fromList [(1,2), (3,4)]
  print $ testF Map.empty [1,2,3] -- show [1024]
  print $ testF a [1,2,3] -- show [1024] too
  print $ a == Map.empty -- False

当然，GHC 已经通知我最新的功能行是多余的。

Pattern …