问题[racket](coding)

这是此 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扩展后的额外访问：

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

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

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

但为什么第三个没有呢？

是否可以仅使用 Racket 创建文件的硬链接？

我确实尝试过使用 (make-file-or-directory-link)，但它只能创建符号链接，而不是硬链接。我正在 *nix 环境中工作，因此我可以使用 (system) 来调用 shell，但我更愿意只在 Racket 上找到实现。

提前致谢。

#lang racket

(define-syntax unpack
  (syntax-rules ()
    [(unpack) (begin (define x 1))]))

(unpack)

(+ x 1)

为什么我会收到错误：x: unbound identifier in: x？

定义宏后，我希望代码能够正确定义 x 且不出现错误？我似乎无法理解，这可能是语法或编译器的问题吗？

我正在准备期末考试，遇到了一个问题。主题是子类型，我理解子类型对记录的工作原理，但对于函数，我完全不明白它是如何工作的。我从考试中取了一个例子，你不必做整个例子。如果有人向我解释它对超类型和子类型的工作原理，对我来说就足够了，所以一个是超类型的例子，一个是子类型的例子，这样我就可以在其他例子中得到指导。

考虑类型 { head : int, neck : int, toes : int list} -> { hands : int, feet : int}

对于以下每种类型，如果它是上述类型的子类型，则回答“子类型”；如果它是上述类型的超类型，则回答“超类型”；如果都不是，则回答“都不是”；如果是子类型和超类型，则回答“两者兼有”。i. { toes : int list, neck : int } -> { hands : int, feet : int} ii. { head : int, neck : int, toes : int list} -> { hands : int, feet : int, arms : int} iii. { toes : int list, neck : int } -> { hands : int, feet : int, arms : int}. iv. { hands : int, feet : int} -> { head : int, neck : int, toes : int list} v.{ head : int, neck : int, toes : int list, fingers : int list} -> { feet : int}

我尝试了这条规则，但没有产生预期的输出。

函数子类型的一般规则是：If t3 <: t1 and t2 <: t4, then t1->t2 <: t3->t4这 t3 <: t1意味着t3 is subtype for t1

谢谢。

我正在尝试使用 Racket 为二十一点游戏制作一整副扑克牌。但是，我有两个问题：

1. 当我使用以下代码时

   ;This function creates a list of all the card faces.
   (define faces '(2 3 4 5 6 7 8 9 10 J Q K A))
   ;This function creates a list of all card suits.
   (define suits '(Clubs Diamonds Hearts Spades))
   
   ;make-deck: Creates a new (unshuffled) 52 card deck
   ;     Returns: The deck (a list of cards)
   ;     Parameters: none
   
   (define make-deck
     (letrec ([pair-items (lambda (x y)
                            (cond
                              [(null? x) '()]
                              [(null? y) '()]
                              [(displayln (cons (car x) (cons (car y) (pair-items x (cdr y)))))]
                              ))])                 
       (pair-items faces suits))
     )
   

   我明白了

   (2 Spades)
   (2 Hearts . #<void>)
   (2 Diamonds . #<void>)
   (2 Clubs . #<void>)
   

   我不知道问题是什么。

2. 我不知道如何重置以将函数iterator中的下一个元素faces与整个函数配对suits。我用吗let？

是否可以写出类似C++的东西

template <typename... T> std::string dup(int n, std::string s, T... tail) {
  std::string result;
  for (int i = 0; i < n; ++i) {
      result += s;
  }
  if constexpr (sizeof...(tail) == 0) {
    return result;
  } else {
    return result + dup(tail...);
  }
}


std::cout << dup(1, std::string("abc"), 2, std::string("xyz"), 3, std::string("a")) << std::endl; // abcxyzxyzaaa

我尝试在 TypedRacket 中编写以下函数

#lang typed/racket

(: repeat-string (-> Integer String String))
(define (repeat-string n str)
  (apply string-append (build-list n (λ (_) str))))

(: dup (All (T ...) (-> Integer String T ... T String)))
(define (dup n s . tail)
  (define result (repeat-string n s))
  (cond [(empty? tail) result]
        [else (string-append result (apply dup tail))])
  )

但我有类型检查错误： Type Checker: Bad arguments to function in 'apply': Domain: Integer String T ... T Arguments: (List T ... T) in: (apply dup tail)

老实说，我不明白为什么争论是(List T ... T)但不是(T ... T)。而且，函数是正确的，非类型化的 Racket 产生正确的结果