An5Drama's questions

这是此 QA 答案的一个后续问题。我使用 Racket v8.16。

来自doc1：compile_time_instantiation.rkt​

(module compile-time-number racket/base
  (require (for-syntax racket/base))
  (begin-for-syntax
    (printf "picked ~a\n" (random)))
  (printf "running\n"))

然后：

$ racket -i -e '(dynamic-require "compile_time_instantiation.rkt" #f)'
Welcome to Racket v8.16 [cs].
picked 0.015421409441077423
running
$ racket -i -e '(require "compile_time_instantiation.rkt")'
Welcome to Racket v8.16 [cs].
picked 0.14007121863188537
running
picked 0.7200261945290138
$ racket -i
Welcome to Racket v8.16 [cs].
> (require "compile_time_instantiation.rkt")
picked 0.7451208846143317
running
$ racket compile_time_instantiation.rkt
picked 0.9883107842338839
running

doc1 说：

同时， dynamic-require 仅实例化一个模块；它不访问模块。这种简化就是为什么前面的一些示例使用 dynamic-require而不是 require 的原因。

当一个模块被实例化时，它主体中的运行时表达式会被评估。

因此，第二条命令中的额外“picked ...”来自require扩展后的额外访问：

当访问一个模块时，其主体中的编译时表达式（例如宏定义）会被评估。

当模块被扩展时，它就会被访问。

通过访问评估的模块编译时表达式包括定义语法形式的右侧和开始语法形式的主体。

但为什么第三个没有呢？

这是来自creference：

赋值运算符的左操作数必须是一元（2 级非强制类型转换）表达式。

该参考页面有 2 次“级别”，即另一个是“优先级”。但优先级 1 有“函数调用”，优先级 2 有“sizeof”，两者都无法分配任何东西。

我可以理解“非强制类型转换”，因为强制类型转换可能会将左值转换为右值。

那么这个“2级”是什么意思呢？

最近尝试获取一个“获取匹配括号的索引”的算法。虽然 perl 语言有些问题，但我能理解该算法的含义。

perl 语法并不晦涩，并且可以通过man perl...文档获得很多信息。

my但我对循环行为有点困惑for。man perlsyn说：

如果变量前面带有关键字“my”，则该变量具有词法作用域，因此仅在循环内可见。否则，该变量隐式地位于循环中，并在退出循环时恢复其以前的值。如果变量之前用“my”声明，则它使用该变量而不是全局变量，但它仍然位于循环中。这种隐式本地化仅发生在非 C 样式循环中。

我知道“非 C 风格循环”是指那些不像的循环for (...;...;...){...}。

第一句话可以通过以下方式显示，类似于文档中显示的示例：

$i = 'samba';
# If the variable is preceded with the keyword "my", then it is lexically scoped, and is therefore visible only within the loop.
for (my $i = 1; $i <= 4; $i++) {
  print "$i\n";
}
print "$i\n";
# 1
# 2
# 3
# 4
# samba

但我不明白第二点是什么意思：

$inner = 'samba';
for ($i = 1; $i <= 4; $i++) {
  $inner = $i + 1;
}
print "inner: $inner\n";
# inner: 5

这里所谓的“本地”var$inner似乎修改了外部的var，并且“以前的值”'samba'无法“恢复”。

第三，我们可以对上面的例子做一些小的调整：

$inner = 'samba';
for ($i = 1; $i <= 4; $i++) {
  my $inner = $i + 1;
}
print "inner: $inner\n";
# inner: samba

这对于“而不是全局的”来说是可以正常工作的。

如何理解循环my中的行为for，尤其是上面引用中的第二句？

后续澄清 choroba 的回答提示：当使用正确的“非 C 风格循环”时，第 1 句和第 2 句似乎意味着是否my用于 var 具有相同的效果。但事实并非如此。

sub foo { print "foo: $x\n"; }

$x = 7;
for $x (1 .. 3) {  # Implicit localisation happens here.
  print "$x\n";
  print "global $::x\n";  # Prints 1 .. 3 correspondingly.
  foo(); # Prints 1 .. 3 correspondingly.
}
print $x;  # Prints 7.

$x = 7;
for my $x (1 .. 3) {  # Implicit localisation happens here.
  print "$x\n";
  print "global $::x\n";  # Always prints 7.
  foo(); # Always prints 7.
}
print $x;  # Prints 7.

这只是和之间的区别localmy，仅意味着动态范围与词法范围，正如那里的最佳答案所示，这也在文档中有所说明。

局部变量只是为全局变量（即包变量）赋予临时值。它不会创建局部变量。这称为动态作用域。词汇作用域由我的...完成。

第三个句子示例可以更新：

$i = 'former';
my $i = 'samba';
for $i (1 .. 4) {
  print "$i\n";
}
# > still localized to the loop
# i.e. uses the outside variable value but maybe there are more than one choices. The doc says to choose "my $i = 'samba';".
print "$i\n"; # not use 'former'
# 1
# 2
# 3
# 4
# samba

针对 ikegami 的回答的后续问题：

如果我们添加：

my $x = 7;
for $x (1 .. 3) {  # Implicit localisation happens here.
  print "$x\n";
  print "global $::x\n"; # Prints nothing for $::x.
  foo(); # Prints nothing for $x.
}
print $x;  # Prints 7.

对于上面的sub foo { print "foo: $x\n"; } ...例子，后者$::x 也不能访问后者定义的全局变量$x = 7;。恕我直言，my创建一个新的变量不应该影响那个全局变量。

但是如果我们将后者的 var 定义为our $x = 7;文档中所说的“包（即全​​局）变量的词汇别名”。那么一切都会像以前一样工作。这是什么原因呢？

在学习SICP时，6.001 lec15具有：

对环境模型的良好理解告诉我为什么（恕我直言）C++ 永远不会有功能齐全的 map、 filter 和 fold-right/fold-left 程序，像 Scheme 一样方便

SICP实现map：

(define (map proc items)
  (if (null? items)
      nil
      (cons (proc (car items))
            (map proc (cdr items)))))

这里每个递归调用map都会为每个参数列表创建一个新的环境(proc items)，因此它们可以独立（类似于proc和cons等）。

但我认为，在 C++ 中，上述代码可以基于堆栈以相同的思想完成。因此仍然保持独立性。

为什么 lec 会说由于“环境模型”， “C++ 永远不会拥有功能齐全的地图”？

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

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

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

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

最近我自学MIT 6.5151课程，先读了CS 61AS Unit 0作为准备，然后根据ps0的要求读了SICP 1到2.1（还有相关的讲义）（也根据CS 61A的讲义要求读了2.2.1），然后读了Software Design for Flexibility (SDF) Prologue，第一章和Scheme的部分附录。

我使用 MIT-Scheme。

目前我正在阅读 SDF 第 2 章并做练习 2.5 (b)。

以下代码会产生奇怪的结果，抛出错误“；对象 square 不适用。”和“；对象 (lambda (x) (square x)) 不适用。”。这里func_polynomial_minimal_unit计算类似于(f(f(g(x)))调用时的内容(func_polynomial_minimal_unit '((f . 2) (g . 1)))

(define (compose f g)
  (define (the-composition . args)
    (call-with-values (lambda () (apply g args))
      f))
  the-composition)

(define (iterate n)
  (define (the-iterator f)
    (if (= n 0)
        identity
        (compose f ((iterate (- n 1)) f))))
  the-iterator)

(define (identity x) x)

(define (func_polynomial_minimal_unit . func_pow_pair_lst)
  (if (null? (car func_pow_pair_lst)) ; contain one null pair
    identity
    (let ((cur_func_pow (caar func_pow_pair_lst)))
      (newline)
      (display cur_func_pow)
      (compose 
        ((iterate (cdr cur_func_pow)) (car cur_func_pow)) 
        (func_polynomial_minimal_unit (cdr func_pow_pair_lst))))))

;; equivalent lambda for the following `func_polynomial_minimal_unit`.
((lambda (x) (expt (* x 9) (expt 2 3))) 3)
;; these works
((compose ((iterate 3) (lambda (x) (square x))) (lambda (x) (* 3 x))) 3)
((compose ((iterate 3) square) (lambda (x) (* 3 x))) 3)

;; these doesn't work
((func_polynomial_minimal_unit '((square . 3) ((lambda (x) (* 3 x)) . 2))) 3)
((func_polynomial_minimal_unit '(((lambda (x) (square x)) . 3) ((lambda (x) (* 3 x)) . 2))) 3)

但如上面的代码所示，这些程序是可以适用的。那么为什么会抛出这些错误呢？

最近在阅读SICP时，有一个脚注写道：

能通过费马测试的数字被称为卡迈克尔数，除了它们极其罕见之外，人们对它们知之甚少。100,000,000 以下有 255 个卡迈克尔数。最小的几个是 561、1105、1729、2465、2821 和 6601。在测试随机选择的非常大的数字的素数时，偶然发现能通过费马测试的值的概率小于宇宙辐射导致计算机在执行“正确”算法时出错的概率。认为算法因第一个原因而不充分，但因第二个原因而不充分，说明了数学和工程学之间的区别。

脚注引用于：

不幸的是，这个断言并不完全正确。确实存在一些能欺骗费马检验的数：数 n 不是素数，但具有这样的性质：对于所有整数 a < n ， an 与 a 模 n 一致。这样的数极其罕见，因此费马检验在实践中相当可靠。[47]

它谈论的是费马检验算法：

; calculate: a^n mod n
(define (expmod base exp m)
  (cond ((= exp 0) 1)
        ((even? exp)
         (remainder (square (expmod base (/ exp 2) m))
                    m))
        (else
         (remainder (* base (expmod base (- exp 1) m))
                    m))))   
(define (fermat-test n)
  (define (try-it a)
    (= (expmod a n n) a))
  (try-it (+ 1 (random (- n 1)))))
; check `times` count although it will fail for Carmichael numbers.
(define (fast-prime? n times)
  (cond ((= times 0) true)
        ((fermat-test n) (fast-prime? n (- times 1)))
        (else false)))

维基百科引用了上述内容

在某些情况下，概率算法是解决问题的唯一实用方法。

有人读过这本书吗？能告诉我第一个参考文献的最后一句话是什么意思吗？

也许这个问题不适合在这里问。但由于 SICP 是关于编程的，所以我在这里问了。

我尝试使用string.match("Í",'%s?[\u{4e00}-\u{9FFF}]+')类似于我们在 JS 或其他语言中工作的方式。但它会匹配一个不必要的字符，如上面的“Í”。

匹配 UTF-8 的官方实现是使用 eacape\ddd但\u{XXX}似乎失败了，因为

Lua 的模式匹配工具逐字节工作

暂时，我使用类似于以下的不稳定解决方法utf8.charpattern：string.match("Í",'%s?[\228-\233][%z\1-\191][%z\1-\191]')基于utf8 编码将输出nil并用于检查 cjk（如“我”），尽管它的左起第二个字节有一个错误的范围。

问：

如何用正则表达式解决这个问题？