【问题标题】:Scheme function that returns a function返回函数的方案函数
【发布时间】:2014-04-22 23:53:12
【问题描述】:

我需要编写一个方案函数,它作为一个函数返回,然后接受另一个参数,例如一个列表,然后返回所需的结果。在此示例中,(c?r "arg") 将返回 -- (car(cdr -- 随后将列表参数返回 2

> ((c?r "ar") '(1 2 3 4))
2
> ((c?r "ara") '((1 2) 3 4))
2

我遇到的问题是如何返回一个在 petite 中接受另一个 arg 的函数?

【问题讨论】:

    标签: scheme


    【解决方案1】:

    你可以这样写一个函数:

    (define (c?r cmds)
      (lambda (lst)
        (let recur ((cmds (string->list cmds)))
          (if (null? cmds)
              lst
              (case (car cmds)
                ((#\a) (car (recur (cdr cmds))))
                ((#\d) (cdr (recur (cdr cmds))))
                (else (recur (cdr cmds))))))))
    

    请注意,我使用d 来表示cdr,而不是r(这对我来说毫无意义)。您也可以使用string-fold-right(需要SRFI 13)更简洁地编写此代码:

    (define (c?r cmds)
      (lambda (lst)
        (string-fold-right (lambda (cmd x)
                             (case cmd
                               ((#\a) (car x))
                               ((#\d) (cdr x))
                               (else x)))
                           lst cmds)))
    

    【讨论】:

      【解决方案2】:

      只是想添加我玩这个。使用SRFI-1。

      (import (rnrs)
              (only (srfi :1) fold)) ;; require fold from SRFI-1
      
      (define (c?r str)
        (define ops (reverse (string->list str)))
        (lambda (lst)
          (fold (lambda (x acc)
                  ((if (eq? x #\a) car cdr) ; choose car or cdr for application
                   acc))
                lst
                ops)))
      

      它与 Chris 的版​​本非常相似(更多的是以前的 fold-right),但我使用 reverse,所以我可以在返回的过程中使用 fold。我通过查看角色来选择调用car 或cdr 中的哪一个。

      编辑

      这是一个具有更多预处理的替代版本。当有#\d 的运行时,它使用tail-ref 和list-tail 作为快捷方式。

      (define (c?r str)
        (let loop ((druns 0) (ops (string->list str)) (funs '()))
          (cond ((null? ops) 
                 (let ((funs (reverse 
                              (if (zero? druns)
                                  funs 
                                  (cons (lambda (x) 
                                          (list-tail x druns)) 
                                        funs)))))
                   (lambda (lst)
                     (fold (lambda (fun lst)
                             (fun lst))
                           lst
                           funs))))
                ((eq? (car ops) #\d) (loop (+ druns 1) (cdr ops) funs))
                ((= druns 0)         (loop 0 (cdr ops) (cons car funs)))
                (else (loop 0 (cdr ops) (cons (lambda (x) 
                                                (list-ref x druns)) 
                                              funs))))))
      

      这可以在#!racket 中变得更简单。我们跳过reverse,只做(apply compose1 funs)。

      (define (c?r str)
        (let loop ((druns 0) (ops (string->list str)) (funs '()))
          (cond ((null? ops) 
                 (let ((funs (if (zero? druns)
                                 funs 
                                 (cons (lambda (x) 
                                         (list-tail x druns)) 
                                       funs))))
                   (apply compose1 funs)))
                ((eq? (car ops) #\d) (loop (+ druns 1) (cdr ops) funs))
                ((= druns 0)         (loop 0 (cdr ops) (cons car funs)))
                (else (loop 0 (cdr ops) (cons (lambda (x) 
                                                (list-ref x druns)) 
                                              funs))))))
      

      【讨论】:

      • list-ref 和 list-tail?不确定如何使用这些来解决这个特定问题。我想我不明白你所说的“压缩”是什么意思。 :-)
      • @ChrisJester-Young 这样的东西.. 写完后我想知道 Racket 是如何实现compose1
      • @Sylwester 大致相当于(define (my-compose1 . fs) (foldr (lambda (f g) (lambda (x) (f (g x)))) identity fs))
      【解决方案3】:

      假设一个compose 过程:

      (define (compose funs . args)
        (if (null? funs)
            (apply values args)
            (compose (cdr funs) (apply (car funs) args))))
      
      (compose (list cdr car) '(1 2 3 4))
      => 2
      

      c?r 可以定义为 compose,如下所示:

      (define (c?r funs)
        (lambda (e) 
          (compose 
           (map
            (lambda (f) (if (char=? f #\a) car cdr))
            (reverse (string->list funs)))
           e)))
      

      然后

      ((c?r "ar") '(1 2 3 4))
      => 2
      ((c?r "ara") '((1 2) 3 4))
      => 2
      

      【讨论】:

        猜你喜欢
        • 1970-01-01
        • 1970-01-01
        • 2016-09-06
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 2015-10-31
        相关资源
        最近更新 更多