Listes comme arguments dans le schéma

Question

Disons que j'ai une procédure foo qui prend trois arguments, et retourne une liste de tous doublé:

(define  (foo a b c)
  (list (* 2 a ) (* 2 b) (* 2 c)))

Ce que je voudrais être en mesure de faire est de créer une autre procédure qui accepte une liste, et appelle foo en utilisant les éléments de la liste comme arguments, comme ceci:

(define (fooInterface myList)
  ...)

(fooInterface (list 1 2 3))

Le hic est, je ne veux pas fooInterface d'écriture en supposant foo aura toujours 3 arguments. Autrement dit, si j'ajoute un argument supplémentaire pour foo, fooInterface devrait encore du travail à condition que la liste adoptée en a 3 éléments.

Answer 1

Qu'est-ce que vous cherchez est appelé apply .

Answer 2

Qu'en est-carte, cela fonctionnerait avec une définition de procédure différente?

(define foo2

(lambda (x)
  (* x 2)))

(map foo2 '(1 2 3 4 5))

Answer 3

Certaines implémentations de faire ce que vous voulez ...

(define (foo lst)
  (map (lambda (x) (* 2 x)) lst))

(define (foo lst)
  (apply (lambda args (map (lambda (x) (* x 2)) args)) lst))

(define foo
  (lambda args (map (lambda (x) (* x 2)) args))

Juste pour le plaisir, une utilisation vraiment cool de apply est dans la transposition d'une matrice. Considérez:

(define grid     '((1 2 3) 
                   (4 5 6) 
                   (7 8 9)
))

Alors,

(apply map list grid)
=> '((1 4 7)
     (2 5 8)
     (3 6 9))