[jhar131]

Hi guys. Never been on this side of the forums before. Anyway, I'm taking a class in Scheme, and I've just gotten my first assignment. It's in two parts. First, write a function that returns the total number of atoms in a given list, regardless of depth. I did this with no problems:

(define (foo x)
 (cond
  ((null? x) 0)
  ((not (list? (car x)))
  (+ 1 (foo (cdr x))))
  (else (+ (foo (car x)) (foo (cdr x)))))) 

Now for the second part, I'm supposed to modify the function to take a list and an atom as parameters, and return the total number of instances of that atom, also regardless of depth. Here's where I've run into trouble. What I have at the moment is:

(define (foo x y)
 (cond
  ((null? x) 0)
  ((not (list? (car x)))
    (( = (car x) y)(+ 1(foo ((cdr x) y)))
    ((eq? (car x) y)(+ 1 (foo ((cdr x) y))))))
 (else   
   ((+ foo ((car x) y))) (foo ((cdr x) y)))))

Perhaps it's my "newness" to functional programming, but I cannot find the problem. When I attempt to execute a trial run, with something like:

(foo '(1 2 3 2 1) 1)

I get this error message: "procedure application: expected procedure, given: (2 3 2 1); arguments were: 1" and it highlights the (( = (car x) y) line. But the error message confuses me further. It seems to me that that is what should happen, after the equivalence evaluation, it recursively passes the cdr and the atom. So.... what gives? If you find the time to look this over and give me a push in the right direction, I would greatly appreciate it. Thanks, Josh

[sepp2k]

(foo ((cdr x) y))

That's your error. (cdr x) evaluates to (2 3 2 1), so the above ends up as (foo ('(2 3 2 1) y)), which is asking scheme to call the "procedure" (2 3 2 1) with the argument y and then call foo with the result. But since (2 3 2 1) is a list and not a procedure, you get the error message you do.

Long story short:

(foo (cdr x) y)

[jhar131]

Sorry it took so long to respond (You know how school can be). First, you were correct, and thanks for the assistance. Positive rep. Secondly, there was still a logical error in the code, and while it executed, it didn't do what I wanted it to. I am posting the corrected code below for any potential future benefit someone may have. Try and note the logical difference, and what I was doing wrong with the original. Once again, thanks sepp2k, for the push.

(define (foo x y)
	 (cond
	  ((null? x) 0)
	  ((not (list? (car x)))
            (cond
              ((eqv? (car x) y)
                 (+ 1 (foo (cdr x) y)))
               (else (foo (cdr x) y))))
	 (else (+ (foo (car x) y) (foo (cdr x) y)))))