Esiste la possibilità di più istruzioni all'interno del corpo di un'istruzione condizionale?

Question

Sono principalmente un programmatore C++ (quindi un OO/imperativo) e trovo piuttosto bizzarro che si possa avere una sola istruzione per valutazione in un'istruzione condizionale come un'istruzione if in Scheme, un linguaggio funzionale.

Ad esempio:

(let ((arg1 0) (arg2 1)) 
    (if (> arg1 arg2) 
     arg1 
     arg2))) 

esempio Erroneo:

(let ((arg1 0) (arg2 1)) 
    (if (> arg1 arg2) 
     (arg1 (display "cool")) 
     (arg2 (display "not cool")))) 

mi dà un errore di tipo "application Procedura: procedura prevista, data: 2; argomenti sono stati: #void"

Questo può essere risolto posizionando detta istruzione condizionale in istruzioni diverse all'interno di un corpo di una funzione definita, ad esempio, con il corpo dell'istruzione condizionale che ha sep dichiarazioni arate ogni volta come segue:

(if (condition) statement1a statement2a) 
(if (condition) statement1b statement2b) 

e così via ...

Va da sé che non è troppo pratico. Per non parlare del sovraccarico del codice duplicato.

Mi manca qualcosa qui o c'è davvero nessun altro modo?

Answer 1

(let((arg1 0)(arg2 1)) 
    (if (> arg1 arg2) 
     (begin 
     (display arg1) 
     (newline) 
     (display "cool")) 
     (begin 
     (display arg2) 
     (newline) 
     (display "not cool")))) 

quando si dice (arg1 (disply "cool")) che si sta insinuando che arg1 dovrebbe essere un proceure.

Answer 2

@RajeshBhat ha dato un buon esempio di utilizzo iniziare con un'istruzione if.

un'altra soluzione è la cond modulo

(let ([arg1 0] [arg2 1]) 
    (cond 
    [(< arg1 0) (display "negative!")] 
    [(> arg1 arg2) (display arg1) (newline) (display "cool")] 
    [else (display arg2) (newline) (display "not cool")])) 

Ogni riga nella forma cond ha un implicito begin che si può effettivamente vedere se si guarda l'attuazione del cond.

(link è alla documentazione Chez Scheme, potrebbe (leggi: probabilmente) non essere stessa implementazione si utilizza come è proprietaria, anche se Petite Chez è gratuito (senza compilatore nella versione petite))

http://scheme.com/tspl4/syntax.html#./syntax:s39

Modifica: Nota importante sui moduli di inizio e quindi su tutte le espressioni che hanno implicito l'inizio.

il seguente codice

(+ 2 (begin 3 4 5)) 

viene valutata a 7. Questo perché il valore di ritorno di una forma begin è l'ultima espressione. Questo è solo qualcosa da tenere a mente quando si inizia. Tuttavia, l'uso di effetti collaterali e cose come i display funzionerà perfettamente nelle posizioni in cui sono 3 e 4.

Answer 3

Una cosa che potrebbe mancare è che in Scheme non esiste una "dichiarazione". Tutto è un'espressione e le cose che potresti considerare dichiarazioni restituiscono anche un valore. Ciò si applica a if, che viene in genere utilizzato per restituire un valore (ad esempio, (if (tea-drinker?) 'tea 'coffee).Diversamente dal C++, la maggior parte degli usi dei condizionali non è destinata a modificare una variabile oa stampare valori. Ciò riduce la necessità di avere più espressioni in una clausola if.

Tuttavia, come sottolineato da Ross e Rajesh, è possibile utilizzare cond (consigliato) o utilizzare begin s nelle clausole if. Nota che se hai molti calcoli che effettuano effetti collaterali in un condizionale, potresti non usare lo Schema in modo idiomatico.

Answer 4

Dal momento che si sta già utilizzando un processo iterativo nella procedura "interiore", perché non usare questa definizione usando nome consentono

(define (fact n) 
    (let inner ((counter 1) (result 1)) 
    (if (> counter n) 
     result 
     (inner (+ counter 1) (* result counter))))) 

Poiché lo stato del processo può essere determinato con solo 2 variabili, non userà quella quantità di memoria.

per esempio (infatti 6) viene calcolata come questo

(inner 1 1) 
(inner 2 1) 
(inner 3 2) 
(inner 4 6) 
(inner 5 24) 
(inner 6 120) 
(inner 7 720) 
720 

Ecco la versione letrec dello stesso procedimento:

(define (fact n) 
    (letrec ((inner 
      (lambda (counter result) 
       (if (> counter n) 
        result 
        (inner (+ counter 1) (* result counter)))))) 
    (inner 1 1))) 

Answer 5

Se ti senti limitato dalla sintassi di schema, si può sempre cambiare la sintassi definendo una macro. Una macro è come una lambda, tranne che genera codice in fase di compilazione (come un modello C++) ei suoi argomenti non vengono valutati prima che la macro venga richiamata.

È possibile creare facilmente una macro per consentire di utilizzare la sintassi che normalmente indica l'applicazione della procedura, ad esempio (arg1 "cool"), per indicare "visualizza tutto all'interno delle parentesi con una nuova riga dopo ogni elemento". (Vorrà dire che solo all'interno della macro, ovviamente.) Ti piace questa:

(define-syntax print-if 
    (syntax-rules() 
    [(_ c (true-print ...) (false-print ...)) 
     (if c 
      (display-with-newlines true-print ...) 
      (display-with-newlines false-print ...))])) 

(define-syntax display-with-newlines 
    (syntax-rules() 
    [(_ e) 
     (begin (display e) (newline))] 
    [(_ e0 e* ...) 
     (begin (display-with-newlines e0) (display-with-newlines e* ...)) ])) 

(let ([arg1 0] [arg2 1]) 
    (print-if (> arg1 arg2) 
      (arg1 "cool") 
      (arg2 "not cool"))) 

uscita:

1 
not cool 

Non ti preoccupare se non si capisce come le definizioni di macro funzionano a destra adesso. Se stai provando Scheme dopo aver imparato C++, senza dubbio stai vivendo un sacco di frustrazione. Dovresti dare un'occhiata al tipo di potere e flessibilità che lo Schema ha davvero.

Una grande differenza tra le macro Scheme e i modelli C++ è che in una macro è disponibile l'intero linguaggio Scheme. Una macro dice, usando Scheme, come trasformare un s-expr in codice Scheme, in qualsiasi modo completamente arbitrario che ti piace. Il compilatore quindi compila il codice Scheme prodotto dalla macro. Poiché i programmi Scheme sono essi stessi s-expr, non ci sono essenzialmente restrizioni (oltre allo scope lessicale e la necessità di racchiudere tutto tra parentesi).

E non permettere a nessuno di scoraggiarti dall'usare gli effetti collaterali se lo desideri. La gloria di Scheme è che puoi fare quello che vuoi.