¿Cuál es el equivalente del esquema de desempaquetado de tuplas?

Question

En Python, que puede hacer algo como esto:

t = (1, 2) 
a, b = t 

... y habrá 1 yb habrá 2. Supongamos que tengo una lista '(1 2) en el esquema. ¿Hay alguna manera de hacer algo similar con let? Si hace una diferencia, estoy usando Racket.

Answer 1

En la raqueta puede utilizar match,

(define t (list 1 2)) 
(match [(list a b) (+ a b)]) 

y cosas relacionadas, como match-define:

(match-define (list a b) (list 1 2)) 

y match-let

(match-let ([(list a b) t]) (+ a b)) 

que funciona para listas, vectores, estructuras, etc. etc. Para valores múltiples, usaría define-values:

(define (t) (values 1 2)) 
(define-values (a b) (t)) 

o let-values. Pero tenga en cuenta que no puedo definir t como una "tupla" ya que los valores múltiples no son valores de primera clase en (la mayoría) implementaciones de esquema.

Answer 2

creo que esto es lo que busca:

• http://www.phyast.pitt.edu/~micheles/scheme/scheme16.html

Mira let-values o let+.

Answer 3

El término general para lo que está buscando (por lo menos en Lisp-mundo) es desestructuración y una macro que pone en práctica se conoce como desestructuración-bind. En Common Lisp, funciona así:

(destructuring-bind (a b c) '(1 2 3) 
    (list a b c)) ;; (1 2 3) 

también funciona para varios "niveles" de anidación:

(destructuring-bind (a (b c) d) '(1 (2 3) 4) 
    (list a b c d)) ;; (1 2 3 4) 

Parece que hay un nice implementation de desestructuración-bind como una macro esquema.

Answer 4

un lenguaje escueto es utilizar aplican con lambda donde debería usar vamos, como:

(define t '(1 2)) 
(apply (lambda (a b) 
      ;; code that would go inside let 
     ) 
     t) 

La ventaja es que funciona en cualquier implementación. Por supuesto, esto solo se puede usar en casos simples, pero a veces eso es todo lo que necesitas.