How to do looping in lisp?

Question

Just started learning and coding lisp, I'm trying to create a program that will continuously accept a number and stops only if and only if the last input number is twice the previous number.

Here's my code

 


----------


(let((a 0)
     (b 0)
     (count 0))
(loop
   (= a b))
   (princ"Enter Number: ")
   (defvar a(read))
   (format t "~% a = ~d" a)
   (setq count (1+ count))
(while
   (!= b(* a 2) || <= count 1)
   (princ "Program Terminated Normally")
)

Thank you

Answer 1

Here's an answer which definitely is not how you would do this in real life, but if you understand what it does you will understand one of the two big important things about Lisps.

(If you understand why the equivalent program would not work reliably in Scheme you'll also understand one of the important things about writing safe programs! Fortunately this is Common Lisp, not Scheme, so it's OK here.)

First of all let's write a little helper function to read integers. This is just fiddly detail: it's not important.

(defun read-integer (&key (prompt "Integer: ")
                          (stream *query-io*))
  ;; Read an integer.  This is just fiddly details
  (format stream "~&~A" prompt)
  (values (parse-integer (read-line stream))))

OK, now here's a slightly odd function called mu (which stands for 'mutant U'):

(defun mu (f &rest args)
  (apply f f args))

And now here is our program:

(defun read-integers-until-double-last ()
  (mu (lambda (c getter current next factor)
        (if (= next (* current factor))
            (values current next)
          (mu c getter next (funcall getter) factor)))
      #'read-integer
      (read-integer)
      (read-integer)
      2))

And here it is working:

> (read-integers-until-double-last)
Integer: 0
Integer: 4
Integer: 3
Integer: -2
Integer: -4
-2
-4

For extra mysteriosity you can essentially expand out the calls to mu here, which makes it either more clear or less clear: I'm not quite sure which:

(defun read-integers-until-double-last ()
  ((lambda (c)
     (funcall c c 
              #'read-integer
              (read-integer)
              (read-integer)
              2))
   (lambda (c getter current next factor)
     (if (= next (* current factor))
         (values current next)
       (funcall c c getter next (funcall getter) factor)))))

Again, this is not how you do it in real life, but if you understand what this does and how it does it you will understand quite an important thing about Lisps and their theoretical underpinnings. This is not all (not even most) of the interesting things about them, but it is a thing worth understanding, I think.