List Racket，应用函数列表：抽象列表函数

我想使用抽象列表函数创建一个函数，该函数将函数列表应用于彼此，而不使用起始元素（起始点为0）

So'（列表添加1 sqr添加1）->2

到目前为止，我已经创建了这些函数各自执行的操作的列表，因此对于上面的示例“（1 0 1）

有什么帮助吗？如果你能给我一个解释就好了，我对foldr，map等东西还是有点怀疑

     (define (apply_functions lof)
     (map (lambda (lof) (lof 0)) lof))

我之前定义了一个复合函数，如下所示，以防它有任何帮助

     (define (composite f g)
      (lambda (x) (f (g x))))

初始问题是否也可以转化为一个函数，该函数接受函数列表和初始编号（0除外），并生成编号结果

例如： '（add1 sqr sub1）4->10

编辑：：

---

因此，看看这个问题，它需要（检查expect（（composite list（list add1 sqr sub1））3）5，其中起始编号不作为变量包含。我已经尝试了代码的多种变体，但无法使其工作

这是一个完美的使用环境，它的行为符合预期：

(define (apply-functions lof)
  (foldr (lambda (f acc) (f acc))
         0
         lof))

(apply-functions (list add1 sqr add1))
=> 2

它之所以有效，是因为我们依次将每个

f

应用于累积结果，从

0

开始。请注意，

foldr

按从右到左的顺序应用列表中的函数（即：应用的第一个函数是列表中的最后一个函数，然后将结果传递给倒数第二个函数，依此类推）。如果要强制执行从左到右的顺序，请改用

foldl

对于问题的最后一部分（编辑后）：我们可以从一个不同的初始数字开始，只需将正确的参数传递到

foldr

，然后返回一个curried函数：

(define ((composite-list lof) init)
  (foldr (lambda (f acc) (f acc))
         init
         lof))

((composite-list (list add1 sqr sub1)) 3)
=> 5

---

这是一个完美的使用环境，其行为符合预期：

(define (apply-functions lof)
  (foldr (lambda (f acc) (f acc))
         0
         lof))

(apply-functions (list add1 sqr add1))
=> 2

它之所以有效，是因为我们依次将每个

f

应用于累积结果，从

0

开始。请注意，

foldr

按从右到左的顺序应用列表中的函数（即：应用的第一个函数是列表中的最后一个函数，然后将结果传递给倒数第二个函数，依此类推）。如果要强制执行从左到右的顺序，请改用

foldl

对于问题的最后一部分（编辑后）：我们可以从一个不同的初始数字开始，只需将正确的参数传递到

foldr

，然后返回一个curried函数：

(define ((composite-list lof) init)
  (foldr (lambda (f acc) (f acc))
         init
         lof))

((composite-list (list add1 sqr sub1)) 3)
=> 5

---

这是一个完美的使用环境，其行为符合预期：

(define (apply-functions lof)
  (foldr (lambda (f acc) (f acc))
         0
         lof))

(apply-functions (list add1 sqr add1))
=> 2

它之所以有效，是因为我们依次将每个

f

应用于累积结果，从

0

开始。请注意，

foldr

按从右到左的顺序应用列表中的函数（即：应用的第一个函数是列表中的最后一个函数，然后将结果传递给倒数第二个函数，依此类推）。如果要强制执行从左到右的顺序，请改用

foldl

对于问题的最后一部分（编辑后）：我们可以从一个不同的初始数字开始，只需将正确的参数传递到

foldr

，然后返回一个curried函数：

(define ((composite-list lof) init)
  (foldr (lambda (f acc) (f acc))
         init
         lof))

((composite-list (list add1 sqr sub1)) 3)
=> 5

---

这是一个完美的使用环境，其行为符合预期：

(define (apply-functions lof)
  (foldr (lambda (f acc) (f acc))
         0
         lof))

(apply-functions (list add1 sqr add1))
=> 2

它之所以有效，是因为我们依次将每个

f

应用于累积结果，从

0

开始。请注意，

foldr

按从右到左的顺序应用列表中的函数（即：应用的第一个函数是列表中的最后一个函数，然后将结果传递给倒数第二个函数，依此类推）。如果要强制执行从左到右的顺序，请改用

foldl

对于问题的最后一部分（编辑后）：我们可以从一个不同的初始数字开始，只需将正确的参数传递到

foldr

，然后返回一个curried函数：

(define ((composite-list lof) init)
  (foldr (lambda (f acc) (f acc))
         init
         lof))

((composite-list (list add1 sqr sub1)) 3)
=> 5

---

你甚至可以做得更一般。实际上，您可以创建一个通用组合：

(define (my-compose . procedures)
  (let* ((proc-in-order   (reverse procedures))
         (init-proc       (car proc-in-order))
         (remaining-procs (cdr proc-in-order)))
    (lambda g 
      (foldl (lambda (x acc) (x acc))         
             (apply init-proc g)
             remaining-procs))))

;; test first makes a list of it's arguments, 
;; then takes the length, then negates that value
(define test (my-compose - length list))

(test 1 2 3 4) ; ==> -4

---

链中的第一个过程（最后一个参数）与初始参数一起作为列表应用，因此它接受多个参数，而链的其余部分只接受一个参数

你甚至可以做得更一般一些。实际上，您可以创建一个通用组合：

(define (my-compose . procedures)
  (let* ((proc-in-order   (reverse procedures))
         (init-proc       (car proc-in-order))
         (remaining-procs (cdr proc-in-order)))
    (lambda g 
      (foldl (lambda (x acc) (x acc))         
             (apply init-proc g)
             remaining-procs))))

;; test first makes a list of it's arguments, 
;; then takes the length, then negates that value
(define test (my-compose - length list))

(test 1 2 3 4) ; ==> -4

---

链中的第一个过程（最后一个参数）与初始参数一起作为列表应用，因此它接受多个参数，而链的其余部分只接受一个参数

你甚至可以做得更一般一些。实际上，您可以创建一个通用组合：

(define (my-compose . procedures)
  (let* ((proc-in-order   (reverse procedures))
         (init-proc       (car proc-in-order))
         (remaining-procs (cdr proc-in-order)))
    (lambda g 
      (foldl (lambda (x acc) (x acc))         
             (apply init-proc g)
             remaining-procs))))

;; test first makes a list of it's arguments, 
;; then takes the length, then negates that value
(define test (my-compose - length list))

(test 1 2 3 4) ; ==> -4

---

链中的第一个过程（最后一个参数）与初始参数一起作为列表应用，因此它接受多个参数，而链的其余部分只接受一个参数

你甚至可以做得更一般一些。实际上，您可以创建一个通用组合：

(define (my-compose . procedures)
  (let* ((proc-in-order   (reverse procedures))
         (init-proc       (car proc-in-order))
         (remaining-procs (cdr proc-in-order)))
    (lambda g 
      (foldl (lambda (x acc) (x acc))         
             (apply init-proc g)
             remaining-procs))))

;; test first makes a list of it's arguments, 
;; then takes the length, then negates that value
(define test (my-compose - length list))

(test 1 2 3 4) ; ==> -4

---

链中的第一个过程（最后一个参数）与初始参数一起作为列表应用，因此它接受多个参数，而链的其余部分只接受一个参数

对不起，我想如果我对这个问题保持接受的话，那就好像这个问题没有被加进去，如果这有任何意义的话。我把它放回去了。谢谢你的帮助！对不起，我想如果我对这个问题保持接受的话，那就好像这个问题没有被加进去，如果这有任何意义的话。我把它放回去了。谢谢你的帮助！对不起，我想如果我对这个问题保持接受的话，那就好像这个问题没有被加进去，如果这有任何意义的话。我把它放回去了。谢谢你的帮助！对不起，我想如果我对这个问题保持接受的话，那就好像这个问题没有被加进去，如果这有任何意义的话。我把它放回去了。谢谢你的帮助！