问题[scheme](coding)

我有以下 Scheme 程序：

(define sg-pair (let ()
                  (define x #f)
                  (cons
                   (call/cc (lambda (c)
                              (set! x c)))
                   x)))

(display sg-pair)
(display "\n")

(if (eq? (car sg-pair) (void))
    (let ()
      ((cdr sg-pair) "first")))

(if (string? (car sg-pair))
    (let ()
      ((cdr sg-pair) 2)))

这将打印以下内容：

(#!void . #<procedure #2>)
(first . #<procedure #2>)
(2 . #<procedure #2>)

我目前对于如何构建这一对的理解是：

1. 延续 ( c) 在调用 时创建call/cc。此时，x是#f，并且尚未被评估为 的第二个参数cons。
2. lambda在传递给的的执行期间call/cc，x被设置为非 false（继续）值。
3. call/cc自然返回，并且不返回任何内容（#!void），并且x从之前的 set 调用中检索到。
4. 当后续调用通过 检索的延续时cdr，我期望在创建延续时已知的 的映射x -> #f被恢复。然后，由于lambda的主体call/cc不会再次运行，因此x将保持为 false。
5. x将在 之后进行评估call/cc，这次是#f，导致第二display个cdr不同，并且第二次调用cdr失败。

x然而，实际发生的情况是，当重新进入延续时，会记住先前的值。为什么？怎么做？Scheme 实际上使用什么机制来记住环境？

我正在尝试制作一个类似于 Common Lisp cl-ppcre 库中的 register-groups-bind 的宏。这个想法是，你用组创建一个正则表达式，并给它一个变量列表，要执行的语句。它将每个正则表达式组与其中一个变量绑定，然后使用这些绑定执行语句。例如：

(register-groups-bind 
    (s1 s2 s3) 
    ("(\\w+) +(\\w+) +(\\w+)" "moe  larry  curly")   
    (list s2 s3 s1)) 

这将返回("larry" "curly" "moe")。另一个复杂之处在于，在变量列表中，除了变量之外，您还可以指定一个在匹配的字符串上运行的函数，例如(register-groups-bind ((string->number x) ... 这样，它会在将匹配的值绑定到 x 之前对其运行 string->number。当您指定这样的函数时，您可以指定多个变量，例如： (string->number x y z)。

我正在尝试在创建 let 绑定的地方进行设置，如下所示：

(let ((s1 (match:substring m 1))
      (s2 (match:substring m 2))
      (s3 (match:substring m 3)))
   ... statements ...

有两件事我不明白如何使用 Scheme 的卫生宏功能。首先，我该如何处理变量列表可能包含变量名称的混合，或包含函数名称和变量的列表这一事实。其次，对于每个 let 绑定，我需要一个序列号来指示要获取哪个正则表达式组。

我可以使用 defmacro 在 Guile Scheme 中做到这一点，如下所示：

(defmacro regex-group-bind (vars re-match . statements)
    (let* ((bind-var (gensym))
       (converted (convert-var-list vars bind-var)))
     `(let ((,bind-var ,re-match))
        (if (regexp-match? ,bind-var)
          (let (,@converted)
            ,@statements)
          #f))))

Whereconvert-var-list 是一个将变量列表转换为绑定列表的函数let。调用时，convert-var-list我需要传入包含正则表达式匹配结果的变量。输出示例如下convert-var-list：

scheme@(guile-user)> (define match-var (gensym))
scheme@(guile-user)> (convert-var-list '(foo bar (string->number x y z)) match-var)

$9 = ((foo (match:substring #{ g5228}# 1))
      (bar (match:substring #{ g5228}# 2))
      (x (string->number (match:substring #{ g5228}# 3)))
      (y (string->number (match:substring #{ g5228}# 4)))
      (z (string->number (match:substring #{ g5228}# 5))))
scheme@(guile-user)> 

我希望能够使用卫生宏来实现这一点，我假设我可能需要使用syntax-case，也许还有像这样的函数convert-var-list，但我不确定这是否是作弊。我需要使用syntax->datum和datum->syntax才能做到这一点吗？

根据scheme.org 实现， GNU Guile 支持 R6 和 R7 版本的 Scheme。并且 guile 可执行文件具有“--r6rs”和“--r7rs”命令行参数。Guile网站称

由于 R7RS 的标准远不如 R6RS 雄心勃勃（参见 Guile 和 Scheme），因此 Guile 很容易支持它。因此，Guile 是 R7RS 的完全符合要求的实现，除了偶尔出现的错误和几个未实现的功能：

• R7RS 指定了使用数据标签读取循环数据结构的语法，例如 #0=(1 2 3 . #0#)。Guile 的阅读器目前不支持此语法；https://bugs.gnu.org/38236。
• 与 R6RS 一样，R7RS 的许多词汇功能与 Guile 的历史语法相冲突。除了 r6rs-hex-escapes 和 hungry-eol-escapes（请参阅与 R6RS 的不兼容性）之外，还需要明确启用 r7rs-symbols 阅读器功能。

并且 scheme.org 上的索引显示vector->string 是 R7RS small 的一部分。但是，当我使用 --r7rs 选项运行 Guile 时，它​​无法识别 vector->string。

“未绑定变量：向量->字符串”

相同的代码适用于 MIT/GNU Scheme

(display (vector->string #(#\H #\i #\!)))  ; => "Hi!"

当我们调用顶级环境的父级在(environment-lookup system-global-environment name)哪里时，它是否也会在其子环境中查找？system-global-environment

从文档上看，它们似乎是分开的。如果是这样，为什么我们在这里定义父环境？

本节中的操作允许您单独检查特定环境与其父环境的绑定，从而揭示环境的框架结构。

Ps：SO 中是否有适合env此问题的标签？（此处的建议environment-variables不合适。）

我正在尝试在 Chez 方案中创建一个符号派生函数。它运行良好（尚未进行简化）：

(define (derive var expr)
;; var is the direction in which you would like to derive
  (if (list? expr)
      (case (car expr)
        ('+    (sum-rule var expr))
        ('-    (sub-rule var expr))
        ('*    (prod-rule var expr))
        ;; other rules
        (else  (atomic-rule var expr )))
      (atomic-rule var expr)))

(define (atomic-rule var expr)
  (if (list? expr)
      expr
      (if (eqv? var expr)
          1
          0)))

(define (sum-rule var expr)
  (let ((args (cdr expr)))
    `(+ ,@(map (lambda (e) (derive var e)) args))))

(define (sub-rule var expr)
  (let ((args (cdr expr)))
    `(- ,@(map (lambda (e) (derive var e)) args))))

(define (prod-rule var  expr)
  (let* ((args (cdr expr))
         (f (car args))
         (g (cadr args)))
    `(+ (* ,f ,(derive var g))
        (* ,g ,(derive var f)))))

我可以执行(derive 'x '(+ (* x x) (* x y)))并得到(+ (+ (* x 1) (* x 1)) (+ (* x 0) (* y 1)))正确的结果。但我还想以编程方式创建从这些表达式返回数值的函数。

我的尝试失败了：

(define (lambda-derive var expr)
  (let ([derivative (derive var expr)])
    (lambda (var) derivative)))

((lambda-derive 'x '(* x x)) 2) => (+ (* x 1) (* x 1)) ;; should be 4

(define-syntax lbd-macro
  (lambda (context)
    (syntax-case context ()
      [(k expr var )
       (with-syntax ([new-var (datum->syntax #'k (syntax->datum #'var))])
         #'(lambda (new-var) expr))])))


((lbd-macro (derive 'x '(* x x)) x) 2) => (+ (* x 1) (* x 1)) ;; should be 4

我感觉我忽略了一些非常明显的东西。有人能提供一些启示吗？（是的，我知道这些尝试没有涵盖多变量情况）

==编辑==

我睡了一个坏觉并决定继续工作，我找到了与 @ignis volens 描述的类似的解决方案，尽管使用了哈希表并且更加黑客化：

(define (lambda-aux variables vals expr)
  (let ((ht (make-eqv-hashtable (length variables))))
    (for-each (lambda (k v) (hashtable-set! ht k v)) variables vals)
    (let loop ((expr expr))
      (if (list? expr)
          (let ((op (car expr))
                (args (map loop (cdr expr))))
            (cons op args))
          (let ((variable (hashtable-ref ht expr #f)))
            (if variable
                variable
                (if (number? expr)
                    expr
                    (error "variable not found"))))))))

(define-syntax lambda-derive
  (syntax-rules ()
    [(_ expr var var* ...)
     (lambda (var var* ...) (eval (lambda-aux '(var var* ...) (list var var* ...) (derive 'var 'expr) )))]))

可以像这样使用：

(define my-test-derivative
  ;;f(x,y) = x^2 + x * y
  ;;df/dx (x,y) = 2*x + y
  (lambda-derive (+ (* x y) (* x x)) x y))
(my-test-derivative 2 2) => 6
(my-test-derivative 8 2) => 18
;; ...

我正在阅读 ChezScheme 中的《小阴谋家》，在第 2 章中我遇到了以下问题。我写了lat的定义？根据书上的说法。

(define lat?
    (lambda (l) 
        (cond 
            ((null? l) #t) 
            ((atom? (car l)) (lat? (cdr l)))
            (else #f)
        )
    )
)

然后定义一个列表

(define l '('bacon 'and 'eggs))

进而

(lat? l)

评估为#f.

问题似乎在于，虽然(car l)评估为'bacon并atom? 'bacon评估为#t，(atom? (car l))但评估为#f。

在 Emacs Lisp 和 Common Lisp 中，返回以下内容nil

(let (x y z)
  x)

但在我尝试过的每个方案中，它都会引发错误。

上述内容在任何计划标准下是否可以接受？

> (equal? '(1 4) (car '('(1 4))))
#f

哎呀，上面的结果应该是#t，因为这些片段的结果是#t

如下：

> (car '('(1 4)))
'(1 4) ; Scheme doesn't get confused by list of a single list

> (equal? '(1 4) '(1 4))
#t. ; Scheme can see the equality of lists

这一定是一些疯狂的范围界定事物或相同的地址事物？测试同一地址的东西？如果我们把它分解，我们仍然得到#f，这表明相等？s-表达式有自己的作用域吗？

> (define piece (car '('(1 4))))
> piece
'(1 4)
> (equal? '(1 4) piece)
#f

平等的？应该迭代每个正在比较的列表的成员，如果所有成员对都相等（事实确实如此），则返回#t。所以，这很奇怪，我一定从根本上不理解 car 或嵌套 s 表达式。

它在 sbcl 中也失败了，所以发生了一些我不明白的黑暗神秘的事情：

* (equalp '(1 4) (car '('(1 4))))
NIL
* (car '('(1 4)))
'(1 4)
* (equalp '(1 4) '(1 4))
T
* 

它在 Racket 中也失败了：

Welcome to DrRacket, version 8.9 [cs].
Language: racket/base, with debugging; memory limit: 128 MB.
> (equal? '(1 4) (car '('(1 4))))
#f

这里是成员的定义？Abelson 和 Sussman SICP 的函数：

(define (member? x list)
     (if (null? list) #f    
         (if (equal? x (car list)) #t 
              (member? x (cdr list)))))

我想我写了完全相同的东西：

(define (my-member item lst)
  (if (null? lst)
    #f
    (if (equal? item (car lst))
      #t
      (my-member item (cdr lst)))))

所以，我是问题所在，但我不明白。这在语义上似乎很明显。