Domanda

Va bene questo può suonare come una domanda ridicola, ma come si fa a restituire un elenco di schema.?

Nessuna soluzione corretta

Altri suggerimenti

In base a vedere alcune delle vostre altre domande, penso che si potrebbe avere difficoltà a raggiungere la testa avvolta attorno ai concetti centrali per un linguaggio funzionale come la Scheme.

A livello si sta imparando Scheme (novizio), ogni funzione che si scrive ha un ingresso e un'uscita, e il corpo di ogni funzione è una singola espressione. Qualunque sia il valore che l'espressione restituisce viene restituito dalla funzione. Non v'è alcun bisogno di esplicitamente "ritorno" nulla come si farebbe in un linguaggio imperativo, come Java o C; succede solo come diretta conseguenza della valutazione dell'espressione.

Il corpo di una funzione è una singola espressione. Non è come Java, dove il corpo di un metodo consiste in una serie di istruzioni:

do this
then do that
then do something else
then return something (maybe)

funzioni Schema valutano una singola espressione; niente di più. Ecco una semplice funzione che aggiunge 5 a qualunque numero è passato come argomento:

(define (add5 x)
  (+ x 5))

Il corpo della funzione è (+ x 5), che è solo un'espressione da valutare. Il valore di x è inserito, la funzione + (aggiunta) viene applicato al x e 5, ed il risultato viene restituito.

Le liste non sono molto diverse. Tutto ciò che serve è un'espressione che costruirà una lista. Due sono già stati menzionati: è usato per costruire una lista da zero se si dispone già di tutti gli elementi; contro viene utilizzato per aggiungere un singolo elemento a un elenco esistente ed è spesso usato in modo ricorsivo.

Ecco una funzione che consuma un numero n e crea l'elenco (n n-1 n-2 ... 0)

(define (makelist n)
  (if (= n 0)
     (list 0)                       ; base case. Just return (0)
     (cons n (makelist (- n 1)))))  ; recursive case. Add n to the head of (n-1 n-2 ... 0)

Sia la base e casi ricorsive, un elenco viene restituito semplicemente valutando un'espressione che utilizza una delle funzioni di costruzione delle liste.

Ecco un altro esempio. Questo si usa la nostra funzione add5 per aggiungere 5 per ogni elemento di una lista di numeri (lon):

(define (add5list lon)
  (if (null? lon)
    `()                 ; base case: lon is empty. Return an empty list.
    (cons (add5 (car lon)) (add5list (cdr lon)))))  ; recursive case.
                                                    ; Add 5 to the head of lon and prepend it to the tail of lon

Anche in questo caso, sia la base e casi ricorsivi stanno tornando liste valutando espressioni che risultano negli elenchi.

La cosa fondamentale da ricordare a proposito Scheme è tutte le funzioni restituiscono qualcosa, e questo qualcosa è semplicemente il risultato della valutazione di un'espressione. Il corpo di una funzione Scheme è una singola espressione.

Probabilmente si desidera semplicemente: '(2 3 5 7 11) o (list 2 3 5 7 11)

?

Si può anche costruire le liste specificando un elemento e un elenco per aggiungerlo a: (cons 2 (cons 3 '()))

Ecco un esempio di restituire un elenco da una funzione:

(define returnlist 
  (lambda(a b c) 
    (cons a (cons b (cons c '())))
))

(returnlist 2 3 4)

Il valore di ritorno sarà la lista: (list 2 3 4)

Un altro modo non-così-ben noto per fare questo:

> ((lambda x x) 2 3 5 7 11)
(2 3 5 7 11)

cioè, la funzione "lista" in sé può essere definito come:

> (define list (lambda x x))
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top