LispForum

Discuss and learn Lisp programming of all dialects

This is a read-only archive of lispforum.com. The forum was locked to new users and posts and is preserved here as static HTML from a database snapshot taken on 2019-09-07.

Convert Scheme to Lisp (Recursive)

6 posts · 2302 views

lispnewbie
#1
I'm using LISP for several months. I know that Scheme is very similar to LISP, but I cannot understand the following Scheme functions. I read somewhere on the internet that "let loop" is used to create a recursive functions, but its argument "let loop ((x x))" doesn't make sense to me. Could you please explain and convert one function from scheme to LISP? Thank you so much for your help.
(define (remove x xs)
  (let loop ((xs xs) (zs '()))
    (cond ((null? xs) (reverse zs))
          ((equal? (car xs) x) (loop (cdr xs) zs))
          (else (loop (cdr xs) (cons (car xs) zs))))))


(define (min es t r)
  (let loop ((es es) (min-e nil) (min-c nil))
    (cond ((null? es) min-e)
          ((or (and (member (cadar es) r) (member (caddar es) r))
               (and (member (cadar es) t) (member (caddar es) t)))
            (loop (cdr es) min-e min-c))
          ((or (not min-c) (< (caar es) min-c))
            (loop (cdr es) (car es) (caar es)))
          (else (loop (cdr es) min-e min-c)))))
gugamilare Administrator
#2

Re: Convert Scheme to Lisp (Recursive)

I guess what confused you is the macro let. In scheme, this:
(let loop ((var1 value1) ... (varN valueN))
  <body>)
is a way of creating loops. It's Common Lisp equivalent would be:
(labels ((loop (var1 ... varN)
            <body>))
  (loop value1 ... valueN))
lispnewbie
#3

Re: Convert Scheme to Lisp (Recursive)

gugamilare, thank you so much. Also, could you help me a little more:

After created in the labels funtions, loop can be called only one time as the second argument. Is it possible to call loop more than one time and inside the body? (like my "min" function).

Do you think there is a way to write "let loop" as a recursive function in common lisp?
gugamilare Administrator
#4

Re: Convert Scheme to Lisp (Recursive)

lispnewbie wrote:After created in the labels funtions, loop can be called only one time as the second argument.
That is not true, you can call the function loop as many times as you want, either inside it's own body, inside the body of another function created in the macro labels or inside the body of labels itself.
lispnewbie wrote:Is it possible to call loop more than one time and inside the body? (like my "min" function).
Yes, there is no problem in calling a function recursively more than once.
lispnewbie wrote:Do you think there is a way to write "let loop" as a recursive function in common lisp?
A local function inside labels that calls itself is already a recursive function. Unless you are thinking about not creating a local function and defining remove and min as recursive functions.

Just one note, though: Common Lisp already has functions named removed and min, so you should rename those functions.
saulgoode
#5

Re: Convert Scheme to Lisp (Recursive)

Just to elaborate a little on the explanation of the Scheme end of things.

The named let form 
(let loop ((var1 value1) ... (varN valueN))
  <body> )
is (as gugamilare suggested) merely syntactic sugar for a form that would originally be something akin to the following: 
(let ((loop #f))
  (set! loop (lambda (var1 ... varN)
                     <body> ))
  (loop value1 ... valueN) )
It would not work to assign the lambda directly -- as in (let ((loop (lambda ... ) -- because then 'loop' will not have been defined at the time the lambda is being created; just as "(let ((x x)) ..." would fail if 'x' has not been defined previously. By creating 'loop' before it is actually bound with the lambda, it can then be referenced within the lambda's body. The initial assignment of 'loop' (#f) does not matter because it gets re-bound to the lambda before the lambda is ever applied to the values.


As a side note, the normal let form: 
(let ((var1 value1) ... (varN valueN))
  <body> )
is similarly syntactic sugar for an application of a lambda: 
((lambda (var1 ... varN)
         <body> )
  value1 ... valueN )
lispnewbie
#6

Re: Convert Scheme to Lisp (Recursive)

Thanks, guys. i didn't wrote these scheme functions, I found them online when I searched for Lisp. The way they named args and values made me confused. Now I can understand and can convert them to a similar common lisp function.
(defun remove1 (x xs)
	(labels ((loop (a1 zs)
			(cond  ((null a1) (reverse zs))
				((equal (car a1) x) (loop (cdr a1) zs))
				(t (loop (cdr a1) (cons (car a1) zs))))
			))
		(loop xs '())
	)
)