Utilisation de delay/force pour implémenter des structures de contrôle en l'absence de macros?

Question

En utilisant Scheme le langage de programmation, comment utiliser delay/force pour implémenter des structures de contrôle sans avoir recours à l'utilisation de macro-installations?

Merci.

Answer 1

La plupart des langages de programmation prennent en charge des structures de flux de contrôle qui n'évaluent pas les arguments de manière redondante.

alors (and (expression_1) ... (expression_N)) retournera #f dès que la première fausse expression sera trouvée.

Si and étaient simplement une fonction dans Scheme, tous ses paramètres auraient été évalués avant d'arriver au corps de l'implémentation de and. Il n'y a aucun moyen de l'implémenter pour contourner cela.

Les macros n'évaluent pas leurs arguments, elles réécrivent simplement les termes avant de les évaluer. Vous pouvez en profiter pour créer des structures de contrôle comme si/cond/ou/et tant que vous en avez déjà un avec qui travailler. En fait, comme un corps lambda n'est pas évalué jusqu'à ce qu'il soit appelé, tout ce dont vous avez vraiment besoin pour les instructions de flux de contrôle évaluées paresseusement, c'est lambda et les macros. Maintenant, si vous ne voulez pas utiliser de macros, alors vos arguments seront évalués. Vous devez les enrouler en lambdas, ou vous pouvez utiliser le délai/la force. Mais alors vous ne passez pas d'expressions dans votre structure de contrôle. Vous passez des expressions enveloppées dans quelque chose. Ça devient un peu moche.

Voici un exemple artificiel utilisant lambdas.

(define bool1 
    (lambda() 
    (display "evaluating bool1\n") 
    #t)) 


(define bool2 
    (lambda() 
    (display "evaluating bool2\n") 
    #t)) 

(define (_or b1 b2) 
    (if (b1) #t 
     (if (b2) #t #f))) 

(define (_and b1 b2) 
    (if (b1) (if (b2) #t #f) #f)) 

utilisation

:

> (_and bool1 bool2) 
evaluating bool1 
evaluating bool2 
#t 
> (_or bool1 bool2) 
evaluating bool1 
#t 
>