I'm a complete CL newb, working my way through PCL, and doing some little coding projects on my own with the things I learn.

One of the hardest battles I'm fighting is trying to break the habit of trying to write things imperatively. I actually find it easier to do this in Scheme, since you really are pushed to do things recursively (I've worked my way through The Little Schemer, too). I'm still getting a feel for how to write things in

*idiomatic*CL - I suspect I'm currently writing

*idiotic*CL.

I was wondering if anyone would be willing to critique this little sample piece of code for overall style. It's a utility function for generating a series of lists according to a certain policy.

EDIT: This code is buggy.

Code: Select all

```
;; This one is supposed to be a bit more fair.
;; The current "order" is defined as the largest index which is currently allowed
;; All combinations of order N are tried before any of order N+1
(defun get-next-prec-balanced (q limits)
(let ((p (copy-seq q))
(len (length q))
(order (loop for idx in q maximizing idx))) ; *FIXME* this prevents us from using arrays
(dotimes (n len)
;; If we haven't reached a hard limit or current order, increment & return
(when (< (elt p n)
(min (elt limits n) order))
(if (> order (loop for idx in p maximizing idx))
(setf (elt p n) order)
(incf (elt p n)))
(return-from get-next-prec-balanced p))
;; If we've reached the current order in the last elt, increase order
(when (and (= (elt p n) order)
(= n (- len 1)))
;; Clean all the things!
(dotimes (m len)
(setf (elt p m) 0))
;; Set the first index whose limit is < the current order to the New Order
(dotimes (m len)
(when (< order (elt limits m))
(setf (elt p 0) (+ order 1))
(return-from get-next-prec-balanced p)))
;; Order is greater than each limit; we're done
(return-from get-next-prec-balanced ()))
;; Otherwise, roll over to 0, which will carry to next position in dotimes loop
(setf (elt p n) 0))
(setf p ())
(return-from get-next-prec-balanced p)))
```