An5Drama's questions

Esta é uma pergunta de acompanhamento desta resposta de QA . Eu uso o Racket v8.16.

Para 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"))

Então:

$ 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 diz:

Enquanto isso, dynamic-require apenas instancia um módulo; ele não visita o módulo . Essa simplificação é o motivo pelo qual alguns dos exemplos anteriores usam dynamic-require em vez de require .

Quando um módulo é instanciado, as expressões de tempo de execução em seu corpo são avaliadas .

Então o extra "picked ..." no 2º comando é da visita extra de requirebeyond quando da expansão:

Quando um módulo é visitado, as expressões de tempo de compilação (como a definição de macro) em seu corpo são avaliadas.

À medida que um módulo é expandido , ele é visitado .

As expressões de tempo de compilação de um módulo que são avaliadas pela visita incluem os lados direitos dos formulários define-syntax e o corpo dos formulários begin-for-syntax .

Mas por que o 3º não tem isso?

Isto é de preferência :

Os operandos esquerdos dos operadores de atribuição devem ser expressões unárias (não convertidas de nível 2).

Essa página de referência tem 2 ocorrências de "level", ou seja, a outra é "precedence level". Mas o nível de precedência 1 tem "Function call" e o nível de precedência 2 tem "sizeof", aos quais não é possível atribuir algo.

Posso entender "não-cast" porque cast pode converter lvalue em rvalue .

Então o que significa esse "nível 2"?

Recentemente, enquanto tentava obter um algoritmo para "Obter índices de parênteses correspondentes" , consegui obter o que esse algoritmo significa, embora com alguns problemas com a linguagem perl.

A sintaxe do Perl não é obscura e pode ser melhor compreendida com man perl...a documentação.

Mas estou um pouco confuso sobre myo comportamento com forloop. man perlsyndiz:

Se a variável for precedida pela palavra-chave "my", então ela é escopo lexical e, portanto, é visível somente dentro do loop. Caso contrário, a variável é implicitamente local para o loop e recupera seu valor anterior ao sair do loop. Se a variável foi declarada anteriormente com "my", ela usa essa variável em vez da global, mas ainda é localizada para o loop. Essa localização implícita ocorre somente para loops que não são do estilo C.

Eu sei que "loops não no estilo C" significa aqueles que não são como for (...;...;...){...}.

A primeira frase pode ser mostrada por esta, que é semelhante ao exemplo mostrado no documento :

$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

Mas não consigo entender o que o 2º significa:

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

Aqui, a suposta var "local" $innerparece modificar a var externa, e o "valor antigo" 'samba'não pode ser "recuperado".

Para o 3º, podemos fazer alguns pequenos ajustes no exemplo acima:

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

Isso funciona como esperado para "em vez do global".

Como entender myo comportamento em forloop, especialmente para a segunda frase acima na citação?

Esclarecimento de acompanhamento com dicas de resposta de choroba: Ao usar o "non C-style loop" correto, a 1ª e a 2ª frases parecem significar que whether myé usado para var tem o mesmo efeito. Mas, na verdade, não é esse o caso.

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.

Essa é apenas a diferença entre localemy que significa escopo dinâmico versus escopo lexical, como mostra a resposta principal, o que também é dito no documento .

Um local apenas fornece valores temporários para variáveis ​​globais (ou seja, pacote). Ele não cria uma variável local. Isso é conhecido como escopo dinâmico. O escopo léxico é feito com meu ...

O exemplo da 3ª frase pode ser atualizado:

$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

pergunta complementar à resposta de ikegami:

Se acrescentarmos:

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.

para o sub foo { print "foo: $x\n"; } ...exemplo acima, então o último $::x também não pode acessar a última var global definida $x = 7;. Na minha humilde opinião, mycria uma nova var que não deve influenciar essa var global.

Mas se definirmos o último var definido como our $x = 7;que é um "alias léxico para uma variável de pacote (ou seja, global)" como diz o documento. Então tudo funciona como antes. Qual é o motivo para isso?

Ao aprender SICP, 6.001 lec15 tem:

Um bom entendimento do modelo de ambiente me diz por que (na minha humilde opinião) C++ nunca terá um mapa totalmente funcional , filtro e procedimentos fold-right/fold-left que sejam tão convenientes quanto os do Scheme

O SICP implementamap :

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

Aqui, cada chamada recursiva mapcriará um novo ambiente para cada lista de argumentos (proc items), para que eles possam ser independentes (semelhante a for proce consetc).

Mas na minha opinião, em C++ o código acima pode ser feito com as mesmas ideias baseadas em stack . Então a independência ainda é mantida.

Por que a aula diz "C++ nunca terá um mapa totalmente funcional " devido ao "modelo de ambiente"?

Quando chamamos (environment-lookup system-global-environment name)where system-global-environmentis the parent of top-level-environment , ele também pesquisará em seu ambiente filho?

Pelo documento , parece que eles estão separados. Se sim, por que definimos o ambiente pai aqui?

As operações nesta seção revelam a estrutura semelhante a um quadro dos ambientes, permitindo examinar as ligações de um ambiente específico separadamente daquelas de seu pai .

Ps Existe alguma tag apropriada como envpara esta pergunta no SO? (As recomendações como environment-variablessão inadequadas aqui.)

Recentemente, quando aprendi sozinho o curso MIT 6.5151, li pela primeira vez a Unidade 0 do CS 61AS como preparação. Em seguida, li o SICP 1 a 2.1 (com notas de aula relacionadas) conforme exigido pelo ps0 (leia também 2.2.1 conforme as notas do CS 61A exigem) e, em seguida, Prólogo de Design de Software para Flexibilidade (SDF) , capítulo 1 e parcialmente Apêndice sobre Esquema.

Eu uso o esquema MIT.

Atualmente estou lendo o capítulo 2 do SDF e fazendo o exercício 2.5 (b).

O código a seguir tem resultados estranhos gerando erros ";O objeto quadrado não é aplicável." e ";O objeto (lambda(x)(quadrado x)) não é aplicável.". Aqui func_polynomial_minimal_unitcalcula algo como (f(f(g(x)))ao ligar(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)

Mas, como mostra o código acima, esses procedimentos podem ser aplicáveis. Então, por que esses erros são lançados?

Recentemente, ao ler o SICP, uma nota de rodapé diz:

Os números que enganam o teste de Fermat são chamados de números de Carmichael, e pouco se sabe sobre eles, exceto que são extremamente raros. Existem 255 números de Carmichael abaixo de 100 milhões. Os menores são 561, 1105, 1729, 2465, 2821 e 6601. Ao testar a primalidade de números muito grandes escolhidos aleatoriamente, a chance de encontrar um valor que engane o teste de Fermat é menor do que a chance de que a radiação cósmica cause o computador cometa um erro ao executar um algoritmo “correto”. Considerar um algoritmo inadequado pela primeira razão, mas não pela segunda, ilustra a diferença entre matemática e engenharia.

A nota de rodapé é referida em:

Infelizmente, esta afirmação não é totalmente correta. Existem números que enganam o teste de Fermat : números n que não são primos e ainda assim possuem a propriedade de que an é congruente com a módulo n para todos os inteiros a < n . Esses números são extremamente raros, portanto o teste de Fermat é bastante confiável na prática. [47]

Está falando sobre o algoritmo de teste de Fermat:

; 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)))

A Wikipedia tem o acima como referência ao dizer

Em alguns casos, os algoritmos probabilísticos são o único meio prático de resolver um problema.

Alguém que leu este livro poderia me dizer o que significa a última frase da primeira referência?

Talvez este problema não seja apropriado perguntar aqui. Mas como o SICP é sobre programação, perguntei aqui.

Tentei usar string.match("Í",'%s?[\u{4e00}-\u{9FFF}]+')algo semelhante a como trabalhamos em JS ou outros. Mas corresponderá a um caractere desnecessário como o 'Í' acima.

A implementação oficial da correspondência de UTF-8 está usando eacape, \dddmas \u{XXX}parece falhar porque

Os recursos de correspondência de padrões de Lua funcionam byte por byte

Temporariamente, eu uso a solução alternativa instável semelhante a utf8.charpattern: string.match("Í",'%s?[\228-\233][%z\1-\191][%z\1-\191]')com base na codificação utf8, a saída será executada nile funcionará para verificar cjk como '我', embora tenha um intervalo errado para o segundo byte da esquerda.

P:

Como resolver esse problema com regex?