Alternative implementation of `if` - incomprehensible behavior

Question

I wanted to write my own if using Boolean logic and macros. I came up with the following implementation:

(defmacro -if (condition if-true if-false)
  "Implements `if` in terms of Boolean logic only"
  `(or (and ,condition ,if-true)
       (and (not ,condition) ,if-false)))

I tested it manually on several cases and it works as expected. But then I wrote a simple test function to perform a series of tests and got one result I still cannot understand. I wrote the function like this:

(defun -if-test ()
  (let ((passed 0)
    (test-format "TEST: ~50a ==> ~:[FAILURE~;SUCCESS~]~%")
    (cases '((return-value (> 2 1) true)
         (return-value (< 2 1) false)
         (standard-output (> 2 1) "true")
         (standard-output (< 2 1) "false"))))
    (dolist (test-case cases)
      (destructuring-bind (type test expected) test-case
    (let ((result (case type
            (return-value
             (eq (-if test 'true 'false) expected))
            (standard-output
             (with-output-to-string (out)
               (string= (-if test (print "true" out) (print "false" out)) expected)))
            (otherwise (error "Unknown test type: ~a" type)))))
      (when result (incf passed))
      (format t test-format test-case result))))
    (format t "Result: ~a/~a tests passed.~%" passed (length cases))))

When I run the tests I get the following output:

TEST: (RETURN-VALUE (> 2 1) TRUE)                        ==> SUCCESS
TEST: (RETURN-VALUE (< 2 1) FALSE)                       ==> FAILURE
TEST: (STANDARD-OUTPUT (> 2 1) true)                     ==> SUCCESS
TEST: (STANDARD-OUTPUT (< 2 1) false)                    ==> SUCCESS
Result: 3/4 tests passed.
NIL

The second failing case apparently gives different results when run by hand than when run as part of this function. I tried debugging it with SLDB and indeed the result is different from standalone execution. I suspect I missed some crucial execution detail or something like that. Can someone explain to me what happens here? Help really appreciated.

P.S. My implementation is Clozure CL.

Answer 1

Your test cases are data. What you feed to -if isn't the evaluation of (< 2 1) but the list with <, 2 and 1 as elements. Anything but nil is a truth value so if you want to test what you do try: (-if '(< 2 1) 'true 'false) ;==> true.

So in this case your test was faulty. There is an error in your macro though:

(-if (progn (print "ONLY ONE TIME!") x) nil t)
; ==> (not x), but it prints "ONLY ONE TIME!" twice!

When making a macro you should always ensure arguments are only evaluated one time, that the order in which they are evaluated are in the argument order because a commonlisper would expect that and that code will not fail no matter what symbols the user uses. The last one calls for use of gensym to ensure hygiene.

To fix your macro error you need to expand to a let form that evaluates the predicate so that the side effects won't be done twice. The name of this variable must be made unique with gensym or a macro that uses gensym like only-once or with-gensyms from popular books. An excellent book is Practical Common Lisp which is free to read and it has a part about macros and common errors and how to fix them

Answer 2

Your -if-test code does not work at all.

CL-USER 18 > (pprint (macroexpand '(-if test 'true 'false)))

(LET ((#:OR-SUBFORM-RESULT1129 (AND TEST 'TRUE)))
  (IF #:OR-SUBFORM-RESULT1129
     #:OR-SUBFORM-RESULT1129
    (OR (AND (NOT TEST) 'FALSE))))

CL-USER 19 > (let ((test '(> 2 1))) (-if test 'true 'false))
TRUE

CL-USER 20 >  (let ((test '(< 1 2))) (-if test 'true 'false))
TRUE

Your code does not test the condition. It tries to test if the variable test is true or false.

If you write a macro and use it, you need to check the code generation, first.

• does the generated code look like you want to?
• are things done more than once in the generated code?
• are things done in the right order in the generated code?
• are there variables or function symbols which should not be in the generated code?
• are my macro arguments processed correctly?

Also the way to check the test results does not do what you want. You do a STRING= to the result of the -IF expression. Not with the output. Also: with-output-to-string returns a string - always. The value of result is then this string. (when result <do-this>) then runs <do-this>, since result is a string, which is always true. In Common Lisp every value, other than NIL, is true.

Generally, if you really want to test a macro with different arguments, you actually need to run the macro expansion. Thus you need to generate the code at test time and run EVAL on it.