Qual è l'equivalente di schema di tuple decompressione?

Question

In Python, posso fare qualcosa di simile:

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

... e sarà 1 e B saranno 2. Supponiamo che io ho una lista '(1 2) nello Schema. C'è un modo per fare qualcosa di simile con let? Se fa la differenza, sto usando Racket.

Answer 1

In racchetta è possibile utilizzare match,

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

e cose correlate come match-define:

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

e match-let

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

che funziona per le liste, vettori, le strutture, ecc ecc. Per valori multipli, useresti define-values:

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

o let-values. Notare che non è possibile definire t come una "tupla" poiché più valori non sono valori di prima classe in (la maggior parte) implementazioni di schemi.

Answer 2

credo che questo è quello che stai cercando:

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

Guarda let-values o let+.

Answer 3

Il termine generale per quello che stai cercando per (almeno in Lisp-mondo) è destrutturazione e una macro che implementa è conosciuto come destrutturazione-bind. In Common Lisp, funziona così:

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

funziona anche per più "livelli" di nidificazione:

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

Sembra che ci sia un nice implementation di destrutturazione-bind come macro schema.

Answer 4

Uno scarno linguaggio è quello di utilizzare applicano con lambda dove occorre utilizzare diamo, come:

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

Il vantaggio è che funziona su qualsiasi implementazione. Ovviamente questo può essere usato solo su casi semplici, ma a volte è tutto ciò di cui hai bisogno.