Fatal编程技术网
  • scheme/
  • Scheme 如何制作一个；定义；在SISC方案的第一个参数中接受字符串的？

Scheme 如何制作一个；定义；在SISC方案的第一个参数中接受字符串的？

scheme

Scheme 如何制作一个；定义；在SISC方案的第一个参数中接受字符串的？,scheme,sisc,Scheme,Sisc,我们将此函数称为“动态定义” 基本上，我想编写一个宏或lambda，其工作原理如下： $ (dynamic-define "variable" 123) $ variable $ => 123 (define-syntax dynamic-define (syntax-rules ()

我们将此函数称为“动态定义”

基本上，我想编写一个宏或lambda，其工作原理如下：

$ (dynamic-define "variable" 123)
$ variable
$ => 123

(define-syntax dynamic-define                                           
    (syntax-rules ()                                                            
      ((_ string <body>)                                                        
       (define (string->symbol string) <body>))))
我试过：

(define-syntax dynamic-define
    (syntax-rules ()
      ((_ string <body>)
       (eval `(define ,(string->symbol string) <body>)))))
我该怎么办

（请：编辑此问题以适合母语英语，并删除此行）

使用
定义宏

#> (define-macro (dynamic-define varstr val)
      `(define ,(string->symbol varstr) ,val))

#> (dynamic-define "variable" 123)
#> variable
123

#> (define-syntax dynamic-define
     (lambda (stx)
       (syntax-case stx ()
         ((k varstr val)
          (with-syntax ([var (datum->syntax-object 
                              #'k
                              (string->symbol (syntax-object->datum #'varstr)))])
            #'(define var val))))))

#> (dynamic-define "variable" 123)
#> variable
123
使用
语法大小写

#> (define-macro (dynamic-define varstr val)
      `(define ,(string->symbol varstr) ,val))

#> (dynamic-define "variable" 123)
#> variable
123

#> (define-syntax dynamic-define
     (lambda (stx)
       (syntax-case stx ()
         ((k varstr val)
          (with-syntax ([var (datum->syntax-object 
                              #'k
                              (string->symbol (syntax-object->datum #'varstr)))])
            #'(define var val))))))

#> (dynamic-define "variable" 123)
#> variable
123
使用
定义宏

#> (define-macro (dynamic-define varstr val)
      `(define ,(string->symbol varstr) ,val))

#> (dynamic-define "variable" 123)
#> variable
123

#> (define-syntax dynamic-define
     (lambda (stx)
       (syntax-case stx ()
         ((k varstr val)
          (with-syntax ([var (datum->syntax-object 
                              #'k
                              (string->symbol (syntax-object->datum #'varstr)))])
            #'(define var val))))))

#> (dynamic-define "variable" 123)
#> variable
123
使用
语法大小写

#> (define-macro (dynamic-define varstr val)
      `(define ,(string->symbol varstr) ,val))

#> (dynamic-define "variable" 123)
#> variable
123

#> (define-syntax dynamic-define
     (lambda (stx)
       (syntax-case stx ()
         ((k varstr val)
          (with-syntax ([var (datum->syntax-object 
                              #'k
                              (string->symbol (syntax-object->datum #'varstr)))])
            #'(define var val))))))

#> (dynamic-define "variable" 123)
#> variable
123
使用
定义宏

#> (define-macro (dynamic-define varstr val)
      `(define ,(string->symbol varstr) ,val))

#> (dynamic-define "variable" 123)
#> variable
123

#> (define-syntax dynamic-define
     (lambda (stx)
       (syntax-case stx ()
         ((k varstr val)
          (with-syntax ([var (datum->syntax-object 
                              #'k
                              (string->symbol (syntax-object->datum #'varstr)))])
            #'(define var val))))))

#> (dynamic-define "variable" 123)
#> variable
123
使用
语法大小写

#> (define-macro (dynamic-define varstr val)
      `(define ,(string->symbol varstr) ,val))

#> (dynamic-define "variable" 123)
#> variable
123

#> (define-syntax dynamic-define
     (lambda (stx)
       (syntax-case stx ()
         ((k varstr val)
          (with-syntax ([var (datum->syntax-object 
                              #'k
                              (string->symbol (syntax-object->datum #'varstr)))])
            #'(define var val))))))

#> (dynamic-define "variable" 123)
#> variable
123
使用
定义宏

#> (define-macro (dynamic-define varstr val)
      `(define ,(string->symbol varstr) ,val))

#> (dynamic-define "variable" 123)
#> variable
123

#> (define-syntax dynamic-define
     (lambda (stx)
       (syntax-case stx ()
         ((k varstr val)
          (with-syntax ([var (datum->syntax-object 
                              #'k
                              (string->symbol (syntax-object->datum #'varstr)))])
            #'(define var val))))))

#> (dynamic-define "variable" 123)
#> variable
123
使用
语法大小写

#> (define-macro (dynamic-define varstr val)
      `(define ,(string->symbol varstr) ,val))

#> (dynamic-define "variable" 123)
#> variable
123

#> (define-syntax dynamic-define
     (lambda (stx)
       (syntax-case stx ()
         ((k varstr val)
          (with-syntax ([var (datum->syntax-object 
                              #'k
                              (string->symbol (syntax-object->datum #'varstr)))])
            #'(define var val))))))

#> (dynamic-define "variable" 123)
#> variable
123
您遇到了一个基本问题：您无法以“干净”的方式进行真正的动态定义，因此您尝试使用
eval
。请注意，上面的两个解决方案都不是动态的——它们所提供的只是编写
“foo”
而不是
foo
的能力。正如我在其他地方所说的，使用
eval
通常是不好的，在这种情况下更糟糕，因为它是从宏使用的
eval
，这使得它非常奇怪。此外，在宏中还有一个隐式的准引号，这会使事情变得更加混乱。您也可以将整个过程定义为一个普通函数：

(define (dynamic-define string <body>)
  (eval `(define ,(string->symbol string) ,<body>)))
但是，如果有一个真正的动态定义包含一个字符串，它会是什么样子呢？您可能希望它定义
b
：

(define a "b")
(dynamic-define a 123)
但是当你考虑它如何与其他绑定交互时，这会变得更加混乱。例如：

(define y 123)
(define (foo s)
  (define x 456)
  (dynamic-define s 789)
  (+ x y))
现在，假设
dynamic define
做了您希望它做的事情，考虑一下使用
（foo“x”）
和
（foo“y”）
会得到什么。更糟糕的是，考虑<代码>（FoO的S）“< /代码>和<代码>（FoO +）”< /代码>。更糟糕的是，那你呢

(foo (random-element '("x" "y" "s" "+" "define")))
?？显然，如果这个
dynamic define
确实做了一些动态定义，那么在不提前知道调用什么名称
foo
的情况下，您就无法理解这段代码。如果没有这样的意义，编译就会消失——但更重要的是，正确性（或者通常，代码的含义）消失了

根据我的经验，这种模式在哈希表和类似设备中处理得更好。

您遇到了一个根本问题：您无法以“干净”的方式进行真正的动态定义，因此尝试使用
eval
。请注意，上面的两个解决方案都不是动态的——它们所提供的只是编写
“foo”
而不是
foo
的能力。正如我在其他地方所说的，使用
eval
通常是不好的，在这种情况下更糟糕，因为它是从宏使用的
eval
，这使得它非常奇怪。此外，在宏中还有一个隐式的准引号，这会使事情变得更加混乱。您也可以将整个过程定义为一个普通函数：

(define (dynamic-define string <body>)
  (eval `(define ,(string->symbol string) ,<body>)))
但是，如果有一个真正的动态定义包含一个字符串，它会是什么样子呢？您可能希望它定义
b
：

(define a "b")
(dynamic-define a 123)
但是当你考虑它如何与其他绑定交互时，这会变得更加混乱。例如：

(define y 123)
(define (foo s)
  (define x 456)
  (dynamic-define s 789)
  (+ x y))
现在，假设
dynamic define
做了您希望它做的事情，考虑一下使用
（foo“x”）
和
（foo“y”）
会得到什么。更糟糕的是，考虑<代码>（FoO的S）“< /代码>和<代码>（FoO +）”< /代码>。更糟糕的是，那你呢

(foo (random-element '("x" "y" "s" "+" "define")))
?？显然，如果这个
dynamic define
确实做了一些动态定义，那么在不提前知道调用什么名称
foo
的情况下，您就无法理解这段代码。如果没有这样的意义，编译就会消失——但更重要的是，正确性（或者通常，代码的含义）消失了

根据我的经验，这种模式在哈希表和类似设备中处理得更好。

您遇到了一个根本问题：您无法以“干净”的方式进行真正的动态定义，因此尝试使用
eval
。请注意，上面的两个解决方案都不是动态的——它们所提供的只是编写
“foo”
而不是
foo
的能力。正如我在其他地方所说的，使用
eval
通常是不好的，在这种情况下更糟糕，因为它是从宏使用的
eval
，这使得它非常奇怪。此外，在宏中还有一个隐式的准引号，这会使事情变得更加混乱。您也可以将整个过程定义为一个普通函数：

(define (dynamic-define string <body>)
  (eval `(define ,(string->symbol string) ,<body>)))
但是，如果有一个真正的动态定义包含一个字符串，它会是什么样子呢？您可能希望它定义
b
：

(define a "b")
(dynamic-define a 123)
但是当你考虑它如何与其他绑定交互时，这会变得更加混乱。例如：

(define y 123)
(define (foo s)
  (define x 456)
  (dynamic-define s 789)
  (+ x y))
现在，假设
dynamic define
做了您希望它做的事情，考虑一下使用
（foo“x”）
和
（foo“y”）
会得到什么。更糟糕的是，考虑<代码>（FoO的S）“< /代码>和<代码>（FoO +）”< /代码>。更糟糕的是，那你呢

(foo (random-element '("x" "y" "s" "+" "define")))
?？显然，如果这个
dynamic define
确实做了一些动态定义，那么在不提前知道调用什么名称
foo
的情况下，您就无法理解这段代码。如果没有这样的意义，编译就会消失——但更重要的是，正确性（或者通常，代码的含义）消失了

根据我的经验，这种模式在哈希表和类似设备中处理得更好。

您遇到了一个根本问题：您无法以“干净”的方式进行真正的动态定义，因此尝试使用
eval
。请注意，上述两种解决方案都不是动态的——它们所提供的只是wri的能力