【问题标题】:Scheme: Return a function?方案:返回一个函数?
【发布时间】:2016-09-06 04:16:00
【问题描述】:

我正在尝试创建一个模仿 car 和 cdr 的“adda”行为的函数,我可以传递任何字符串 'a's 和 'd's。这个想法是返回一个函数,然后在后面的列表上执行。对该函数的调用可能如下所示:

((cxr "dd") '(1 2 3))

我已经逐步建立到我认为它应该工作的地方,首先是创建一个返回正确字符串 car 和 cdr 的 letrec。然后将 letrec 的主体移动到定义中的 lambda 主体。

(define (cxr cmdString)  ;named function to call
    (lambda (X)          ;beginning of un-named function to return
        (                   
            (cond
                ;if the string passed in is empty, return the arguments to the second function
                ((= 0 (string-length cmdString)) 'X)

                ;if its an 'a', add a call to car to the list and call the function again with a shorter command string.
                ((char=? #\a (string-ref cmdString 0)) (list (quote car) (cxr (substring cmdString 1 (string-length cmdString))))) 

                ;if its a 'd', add a call to cdr to the list and call the function again with a shorter command string.
                ((char=? #\d (string-ref cmdString 0)) (list (quote cdr) (cxr (substring cmdString 1 (string-length cmdString))))) 
            )
        )
    )
)

((cxr "a") '(1 2 3)) ;call the function

使用 Repl.it,我收到一条对我来说毫无意义的可怕错误消息。我有点想办法让它以不同的方式工作,但我想知道我做错了什么。

我构建的 Letrec,返回正确的 car 和 cdr 字符串:

(letrec
    (
        (cxr
            (lambda (cmdString)
                (cond
                    ((= 0 (string-length cmdString)) 'X)
                    ((char=? #\a (string-ref cmdString 0)) (list (quote car) (cxr (substring cmdString 1 (string-length cmdString)))))
                    ((char=? #\d (string-ref cmdString 0)) (list (quote cdr) (cxr (substring cmdString 1 (string-length cmdString)))))
                )
            )   
        )
    )
(cxr "daa") ;can change "daa" to any combination of 'd's and 'a's.
)

具有我正在寻找的行为的最终版本,没有经过很好的测试(而且有点丑陋):

(define (cxr X)
(list 'lambda '(X) 
    (letrec
        (
            (computecxr
                (lambda (cmdString)
                    (cond
                        ((= 0 (string-length cmdString)) 'X)
                        ((char=? #\a (string-ref cmdString 0)) (list 'car (computecxr (substring cmdString 1 (string-length cmdString)))))
                        ((char=? #\d (string-ref cmdString 0)) (list 'cdr (computecxr (substring cmdString 1 (string-length cmdString)))))
                    )
                )   
            )
        )
        (computecxr X)
    )
)
)

(print (cxr "a"))
((eval (cxr "dd")) '(1 2 3))

任何建议都会有所帮助。谢谢。

编辑:亚历克西斯,我看不出我的问题与其他问题之间的相关性。我没有在我的程序中使用 if ,也不是我得到的错误。你能解释一下为什么你认为它是重复的吗?

【问题讨论】:

  • 如果是重复的,我很抱歉。我在这里查看了许多处理返回函数的 Scheme 文章。
  • 它可能重复的原因是两者都是由相同的简单括号错误引起的,将语句包装在不属于的括号中。但是,如果您修复了这些括号错误,那么这里可能会有一个很好的问题,与此分开。
  • 好吧,我没认出来。这是来自更大课程的“接触函数式编程”部分,我们在其中讨论不同的编程范式,并在每个范式中进行一些编码。正因为如此,我会说这是我的……第三次?……时间编写方案。我所有的语法参考(除了互联网)是我的导师提供的幻灯片,其中包含不同的 sn-ps 代码示例。我可能犯了一个错误,试图用猴看猴做我的代码。

标签: scheme


【解决方案1】:

好的。让我们对您的问题进行第一次尝试,并稍微清理一下,使用适当的缩进和正常的) 放置:

(define (cxr cmdString) ; named function to call
  (lambda (X)           ; beginning of un-named function to return
    ((cond
       ; if the string passed in is empty, return the arguments to the second function
       [(= 0 (string-length cmdString)) 'X]

       ; if its an 'a', add a call to car to the list and call the function again with a shorter command string.
       [(char=? #\a (string-ref cmdString 0))
        (list (quote car) (cxr (substring cmdString 1 (string-length cmdString))))]

       ; if its a 'd', add a call to cdr to the list and call the function again with a shorter command string.
       [(char=? #\d (string-ref cmdString 0))
        (list (quote cdr) (cxr (substring cmdString 1 (string-length cmdString))))]))))

((cxr "a") '(1 2 3)) ; call the function

现在更容易发现问题。第一个问题是一个简单的括号错误,您将 lambda 的主体包裹在一组不应该存在的括号中。请记住,在方案中,括号通常表示函数调用。这就是您收到application: not a procedure 错误的原因。现在有了这个固定:

(define (cxr cmdString) ; named function to call
  (lambda (X)           ; beginning of un-named function to return
    (cond
      ; if the string passed in is empty, return the arguments to the second function
      [(= 0 (string-length cmdString)) 'X]

      ; if its an 'a', add a call to car to the list and call the function again with a shorter command string.
      [(char=? #\a (string-ref cmdString 0))
       (list (quote car) (cxr (substring cmdString 1 (string-length cmdString))))]

      ; if its a 'd', add a call to cdr to the list and call the function again with a shorter command string.
      [(char=? #\d (string-ref cmdString 0))
       (list (quote cdr) (cxr (substring cmdString 1 (string-length cmdString))))])))

((cxr "a") '(1 2 3)) ; call the function

代码给出结果:

'(car #<procedure>)

它返回一个包含两个元素的列表,相当于(list 'car #&lt;procedure&gt;)。这可能不是你的意思。我猜你希望它返回列表'(1 2 3) 的car,即1。所以首先,在评论中写下:

;; cxr : CmdString -> (ConsTree -> Any)
;; Given a command string containing 'a' and 'd' characters, returns
;; a function that gets the corrosponding element in the cons tree.
;; For example, (cxr "a") should return a function equivalent to car,
;; (cxr "d") should return a function equivalent to cdr, and
;; (cxr "add") should return a function equivalent to caddr.

现在我们已经记录了(cxr ...) 返回的内容,我们可以用它做点什么。我们可以在递归的情况下正确使用它。它返回一个接受 cons 树的函数,因此我们可以将其应用于 X,这是我们的 cons 树:((cxr ...) X)。这将返回与字符串的其余部分相对应的 X 的子片段,对于 "add" 情况,它是 (cddr X)。因此,您只需将car 或cdr 应用于此:

; 'a' case
(car ((cxr ...) X))
; 'd' case
(cdr ((cxr ...) X))

在上下文中:

(define (cxr cmdString) ; named function to call
  (lambda (X)           ; beginning of un-named function to return
    (cond
      ; if the string passed in is empty, return the arguments to the second function
      [(= 0 (string-length cmdString)) 'X]

      ; if its an 'a', call car on a recursive call using the rest of the command string.
      [(char=? #\a (string-ref cmdString 0))
       (car ((cxr (substring cmdString 1 (string-length cmdString))) X))]

      ; if its a 'd', call cdr on a recursive call using the rest of the command string.
      [(char=? #\d (string-ref cmdString 0))
       (cdr ((cxr (substring cmdString 1 (string-length cmdString))) X))])))

((cxr "a") '(1 2 3)) ; call the function

现在这给出了这个错误:

car: contract violation
  expected: pair?
  given: 'X

'X 是从哪里来的?基本情况。我们还需要修复基本情况,但这很简单,只需使用X 而不是'X:

;; cxr : CmdString -> (ConsTree -> Any)
;; Given a command string containing "a" and "d" characters, returns
;; a function that gets the corrosponding element in the cons tree.
;; For example, (cxr "a") should return a function equivalent to car,
;; (cxr "d") should return a function equivalent to cdr, and
;; (cxr "add") should return a function equivalent to caddr.
(define (cxr cmdString) ; named function to call
  (lambda (X)           ; beginning of un-named function to return
    (cond
      ; if the string passed in is empty, return the argument to the second function
      [(= 0 (string-length cmdString)) X]

      ; if its an 'a', call car on a recursive call using the rest of the command string.
      [(char=? #\a (string-ref cmdString 0))
       (car ((cxr (substring cmdString 1 (string-length cmdString))) X))]

      ; if its a 'd', call cdr on a recursive call using the rest of the command string.
      [(char=? #\d (string-ref cmdString 0))
       (cdr ((cxr (substring cmdString 1 (string-length cmdString))) X))])))

测试它:

> ((cxr "a") '(1 2 3))
1
> ((cxr "d") '(1 2 3))
'(2 3)
> ((cxr "add") '(1 2 3))
3
> ((cxr "adda") '((1 2 3) 4))
3

更新

本着@Sylwester 的compose 答案的精神,您可以将此代码转换为使用compose 而不是(lambda (X) ...),同时保留一些与原始代码相同的结构:

;; cxr : CmdString -> (ConsTree -> Any)
;; Given a command string containing "a" and "d" characters, returns
;; a function that gets the corrosponding element in the cons tree.
;; For example, (cxr "a") should return a function equivalent to car,
;; (cxr "d") should return a function equivalent to cdr, and
;; (cxr "add") should return a function equivalent to caddr.
(define (cxr cmdString)
  (cond
    ; if the string passed in is empty, return the identity function.
    [(= 0 (string-length cmdString)) identity]

    ; if its an 'a', compose car with a recursive call using the rest of the command string.
    [(char=? #\a (string-ref cmdString 0))
     (compose car (cxr (substring cmdString 1 (string-length cmdString))))]

    ; if its a 'd', compose cdr with a recursive call using the rest of the command string.
    [(char=? #\d (string-ref cmdString 0))
     (compose cdr (cxr (substring cmdString 1 (string-length cmdString))))]))

如果你看一下结构,这与你最初写的并没有太大的不同。它没有 lambda,因为它使用 compose 构建函数,它返回基本情况的标识函数而不是符号 'X,对于递归情况,它使用 compose 你使用 @987654354 @ 和quote。

【讨论】:

  • 该死,现在我有了三个绝妙的答案。一个展示正确的做事方式,一个展示我最初做错了什么,还有一个我不太明白。 Renzo 和 Alex Knauth,你们非常有帮助,我真的很感激。 Sylwester,我相信如果有更多的接触和经验,你的回答会很有启发性。我的意思是,我知道什么与数学有关,你有 f(g(x)) 这正是我想要做的,但你给出的例子对我来说仍然遥不可及。
  • 是的,合成是一种很好的方式。实际上想一想,我可以更进一步地使用 compose...
  • 这样看来,compose 更有意义。在 Sylwester 的例子中,我只是迷失了一切。所有lets 和lambdas 和conds。我看不到 compose 实际上在做什么。有了这个,就明显多了。 import 的东西也让我失望了,我们没有被告知有什么要导入的东西。
【解决方案2】:

原始访问器不是神奇生成的,而是通常作为组合的全局绑定。

但是可以做到这一点。称为compose 的通用过程通常是将过程链接在一起的东西,这就是这里发生的事情。使用 compose 可以非常简单地创建 cxr 而无需使用 eval。编译器几乎没有机会优化使用eval 的代码,并且如果评估代码以某种方式包含来自用户输入的元素,则会出现安全问题。

#!r6rs
(import (rnrs)
        (only (srfi :1) fold)
        (only (srfi :13) string-fold-right))

(define compose
  (let* ((apply-1
          (lambda (proc value)
            (proc value)))
         (gen
          (lambda (procs)
            (let ((initial (car procs))
                  (additional (cdr procs)))
              (lambda args
                (fold apply-1
                      (apply initial args)
                      additional))))))
    (lambda procs
      (cond ((null? procs) values)
            ((null? (cdr procs)) (car procs))
            (else (gen (reverse procs)))))))

(define (cxr receipt)
  (define (add-proc char acc)
    (cons (if (eqv? char #\a) car cdr) acc))

  (apply compose
         (string-fold-right add-proc
                            '()
                            receipt)))

;; test
(define test '(1 2 3 4 5 6))
(define my-caddr (cxr "add"))
(define compose-caddr (compose car cdr cdr))

(caddr test)         ; ==> 3
(my-caddr test)      ; ==> 3
(compose-caddr test) ; ==> 3

【讨论】:

  • 当我发现自己做错了什么时,我查看了compose 的文档,但我认为这对于我想要做的事情来说有点复杂。在看了你的例子之后,我不得不承认,我真的不知道发生了什么......
  • @Teravian (compose p3 p2 p1) 等同于 (lambda args (p3 (p2 (apply p1 args))))。它的定义稍微复杂一些,因为它适用于任意数量的参数。
【解决方案3】:

在您的代码中,由于错误使用括号而导致语法错误的一部分,您正在尝试使用quote 和list 构建一个列表,然后必须对其进行评估得到结果。

但是如果你想探索函数式编程,你应该避免从具体的数据结构的角度来考虑函数,比如列表。相反,您应该开始将它们视为语言的值,就像整数和字符串一样,例如作为由其他函数返回的函数,或者应用于其他表达式的表达式,因为它们评估为功能。

这是您的问题的可能解决方案,编写为高级函数,并使用 DrRacket 进行了测试:

(define (cxr cmd-string)
  (if (= 0 (string-length cmd-string))
      (lambda (x) x) 
      (let* ((first-char (string-ref cmd-string 0))
             (f (if (char=? first-char #\a) car cdr)))
        (lambda (x) (f ((cxr (substring cmd-string 1 (string-length cmd-string))) x))))))

((cxr "add") '(1 2 3)) ;  => 3

第一个测试检查字符串是否为空,在这种情况下返回标识函数(即函数返回其参数)。

否则,字符串的第一个字符绑定first-char,然后对应的函数绑定f(注意car和cdr是两个原始函数),最后返回值是一个带有参数x 的新函数,它将f 应用于x 的结果,该函数由cxr 的递归调用产生。

添加

要了解函数式方法与“构建列表表示函数”之间的区别,特别是递归的不同用法,请将上述函数与以下函数进行比较:

(define (mk-cxr cmd-string)
  (define (mk-body string)
    (if (= 0 (string-length string))
        '(x)
        (let* ((first-char (string-ref string 0))
               (operation (if (char=? first-char #\a) 'car 'cdr)))
          (list (cons operation (mk-body (substring string 1 (string-length string))))))))       
  (cons 'lambda (cons '(x) (mk-body cmd-string))))

(mk-cxr "add")   ;  => (lambda (x) (car (cdr (cdr x))))

【讨论】:

  • 这对于提供一种重新解决我正在尝试解决的问题的方法非常有帮助。最大的部分是在第二个let 语句中将函数分配给变量。尽管我对 x 如何绑定到您想要执行该功能的列表仍然有些模糊。这是我在编写初始解决方案时最大的绊脚石之一(我们只是做了一个“生成一个可以evaled 来调用函数的字符串”练习,这可能没有帮助)。我一直想向cxr 函数添加第二个参数,或者硬编码x 的值。
  • 我还认为递归是问题所在,反复调用外部 cxr 函数。我想为内部 lambda 添加一个名称,这样我就可以跳过外部函数,直接跳到内部函数并直接给它参数。
  • @Teravian,这个练习实际上并不容易。如果您想构建一个表示该函数的列表,然后调用eval 来应用它,您必须考虑列表构建原语,并递归构建这样一个列表(但在此情况下宏将是更好的选择)。相反,如果您想构建一个函数,那么您应该开始将函数视为黑匣子,在其中您不能“输入”到“修改”,但您可以仅应用(或绑定到某个标识符,比如f,或者从另一个函数返回)。当你理解了这一点,你就理解了函数式编程。
  • @Teravian,我编辑了答案以比较这两种方法。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多