Un bon moyen de programmer en Lisp?

Question

Je suis nouveau à Common Lisp, et je me suis retrouvé en profitant des fonctions de la fonction retourne des valeurs. Voici deux exemples triviaux:

(defun safe-avg (a b) 
    (and (numberp a) (numberp b) (/ (+ a b) 2))) 

(defun safe-div (a b) 
    (and (numberp a) (numberp b) (> b 0) (/ a b))) 

Mais je aurais pu l'écrire comme ça (sans doute plus clair):

(defun safe-avg (a b) 
    (if (and (numberp a) (numberp b)) 
     (/ (+ a b) 2))) 

(defun safe-div (a b) 
    (if (and (numberp a) (numberp b) (> b 0)) 
     (/ a b))) 

Je voulais savoir quelle est la méthode préférée de faire quelque chose comme ça et le raisonnement derrière cela, avant que je commence à abuser de cette habitude.

Answer 1

Puisque vous n'utilisez pas la branche "else", vous pouvez utiliser when:

(defun safe-div (a b) 
    (when (and (numberp a) (numberp b) (> b 0)) 
    (/ a b))) 

qui est le même que:

(defun safe-div (a b) 
    (if (and (numberp a) (numberp b) (> b 0)) 
     (/ a b) 
     nil)) 

qui est la même chose que votre version, mais plus explicite.

Quoi qu'il en soit, toutes ces fonctionnalités sont équivalentes. Je préférerais réfléchir à la façon dont ces fonctions doivent être utilisées. Si vous le faites comme ça, vous devrez faire des vérifications nuls chaque fois que vous appelez ces fonctions, ce qui est fastidieux.

Il serait préférable d'utiliser des conditions, soit par le biais de déclarations de type, soit par le biais d'assertions, soit par l'intermédiaire de when & hellip; signal formes. Vous pouvez ensuite définir des gestionnaires et des redémarrages pour ces conditions pour des parties entières de votre programme. Pour en savoir plus: Practical Common Lisp, ch. 19.

Dans ce cas, je ne serais pas ici gérer cela du tout:

(defun safe-div (a b) 
    (/ a b)) 

(ou plutôt, il suffit d'utiliser /). Si / obtient les mauvais arguments, il signalera une erreur que vous pouvez ensuite gérer à l'extérieur, où vous savez ce que cela pourrait signifier.

Answer 2

La première forme est idiomatiquement acceptable. Ce n'est pas le meilleur exemple d'utilisation efficace de la valeur de retour de AND, puisque la seconde forme est un peu plus claire sans être plus longue. Mais vous ne devriez pas avoir peur d'utiliser LISP comme prévu!

Par exemple, aller dans un (à déconseiller) direction ... On pourrait soutenir que le « retour néant » implicite de déclarations if pourrait être source de confusion et d'essayer de la structure parallèle if/else être plus claire:

(defun safe-avg (a b) 
    (cond ((and (numberp a) (numberp b)) 
     (/ (+ a b) 2)) 
     (t 
     nil))) 

C'est mauvais. Et vous ne voulez pas descendre cette route. Alors allez-y et utilisez les expressions et découpez la quantité de code avec de belles évaluations, et utilisez des commentaires pour prendre le relais pour rappeler aux autres (et à vous-même) comment cela fonctionne si quelque chose n'est pas évident.