Combined weight of items in list - recursion

Question

I'm working in Dr. Racket, and it's my first time using a functional language so I am quite confused.
I just need to add the weights of each different "animal" in a list.
All the different animals have a "weight" attribute, but racket won't let me access the "weight" item of any given list element because it claims it's "not defined"
What I have so far:
(define (zoo-weight animals)
(cond [(empty? animals) 0]
[else (+ (first weight)(zoo-weight (rest animals)))])) ;This is where I get the error for weight, saying it is undefined.
If someone could just let me know how to reference weight regardless of list item (snake-weight, cow-weight, etc) this whole functional thing is just sort of confusing.
Thanks!

Answer 1

You almost got it! try something like this:
(define (zoo-weight animals)
(cond [(empty? animals) 0]
[else (+ (weight (first animals))
(zoo-weight (rest animals)))]))
The problem is that you can't say (first weight). What is weight? it's probably a function that applies to animals, or a variable. So, you wrote: "take the first element of weight". Clearly that doesn't make sense, we want to take the first animal from the list, and then find out that animal's weight, before advancing to the next animal in the list.
As shown above use the following expression in your procedure, it should work assuming that the function that gives us an animal's weight is called weight (if not, use the appropriate function - animal-wight, weight-animal, I don't know how you called it):
(weight (first animals))
UPDATE
Now that you mention that each animal has a different weight function, I have a couple of comments. This is a symptom of bad design, the same function should work on all kinds of animals, to avoid those long conditionals everywhere (and it'll be a hassle if we add a new kind of animal!). I don't know how the animals are currently implemented, so I can't make further suggestions. But if it's not possible to fix the current representation, at least encapsulate the conditional in a single place, like this:
(define (weight animal)
; find the correct weight function
((cond ((snake? animal) snake-weight)
((dillo? animal) dillo-weight)
((ant? animal) ant-weight)
(else (error "Unknown animal:" animal)))
; apply the function to the animal
animal))
Now my implementation of zoo-weight will work without any modification, and there's no need to duplicate the conditional wherever the weight is needed. And if writing more than one function is a problem (and I can't imagine why your teacher would put that restriction, functional programming encourages building lots of reusable functions!), we can always in-line the code:
(define (zoo-weight animals)
(cond [(empty? animals) 0]
[else (+ (let ([animal (first animals)])
((cond ((snake? animal) snake-weight)
((dillo? animal) dillo-weight)
((ant? animal) ant-weight)
(else (error "Unknown animal:" animal)))
animal))
(zoo-weight (rest animals)))]))
Also, borrowing from #Jack's solution, we can use a lambda (an anonymous function) together with the higher-order map procedure. This still counts as a single function:
(define (zoo-weight animals)
(apply +
(map
(lambda (animal)
((cond ((snake? animal) snake-weight)
((dillo? animal) dillo-weight)
((ant? animal) ant-weight)
(else (error "Unknown animal:" animal)))
animal))
animals)))

Answer 2

Assuming you've got a list of animals and a function weight that takes one animal and gives you its weight, you mgiht be better off using apply and map here instead of doing the recursion yourself:
(define (zoo-weight animals)
(apply + (map weight animals)))
map takes a function and a list and calls the function once for each thing in the list, e.g. (map sqrt '(9 16 25)) evaluates to the list '(3 4 5). The apply function takes a function and a list and calls the function with the list items as arguments, e.g. (apply + '(1 2 3)) is the same as (+ 1 2 3). By combining the two, you get the functionality you want. It can be difficult to learn to think in terms of these patterns, but once you do the benefits are enormous. But you should get a solid understanding of the recursive pattern in Oscar Lopez's answer first, that is absolutely fundamental to understanding functional programming patterns.
Update
That bit about not having a general weight function and only being allowed to create one is quite the restriction. Normally in functional languages, lots of general functions and helper functions are good to have. You can use the anonymous function approach outlined in Oscar's answer, but I would add that it might be good to bind this function to a name in the body of the zoo-weight function using a let:
(define (zoo-weight animals)
(let ([weight (lambda (animal)
((cond [(snake? animal) snake-weight]
[(dillo? animal) dillo-weight]
[(ant? animal) ant-weight]
[else (error "Unknown animal:" animal)])
animal))])
(apply + (map weight animals)))
You can also achieve the same thing with an inner define:
(define (zoo-weight animals)
(define (weight animal)
((cond [(snake? animal) snake-weight]
[(dillo? animal) dillo-weight]
[(ant? animal) ant-weight]
[else (error "Unknown animal:" animal)])
animal))
(apply + (map weight animals)))
This is basically the same thing as defining a separate helper function, but the weight function is hidden inside the zoo-weight function - no code anywhere outside the zoo-weight function can use the helper.
As Joshua notes, there are other higher-order functions you can use such as variants of foldl. foldl take a function, an initial value, and a list and reduces the list to one value using the function in steps. (foldl + 0 '(1 2 3)) is the same as (foldl + 1 '(2 3)) which is the same as (foldl + 3 '(3)) which is 6. In Racket, using foldl instead of (apply + (map weight animals)) would look like either of these:
(foldl + 0 (map weight animals))
(foldl (lambda (animal acc) (+ acc (weight animal))) 0 animals)
Racket also offers the for/fold macro, which can make the logic clearer at times:
(for/fold ([sum 0]) ([animal animals])
(+ sum (weight animal)))
This folding function based on Common Lisp's reduce works as well:
(define (reduce f xs #:key [key-func #f])
(let ([xs (if key-func (map key-func xs) xs)])
(foldl f (first xs) (rest xs))))
(reduce + animals #:key weight)

Answer 3

Thank you all for your responses, I gave up-votes for your time. All of your answers are good, except that I'm only allowed one function, so I couldn't make a "weight" function that gets the weight of any animal. I ended up having to do it with a large "cond" statement below. I know this is less good code, but it gets the job done without having to build any other functions (which is my only option):
(define (zoo-weight animals)
(cond [(empty? animals) 0]
[(snake? (first animals)) (+(snake-weight (first animals))(zoo-weight (rest animals)))]
[(dillo? (first animals)) (+(dillo-weight (first animals))(zoo-weight (rest animals)))]
[(ant? (first animals)) (+(ant-weight (first animals))(zoo-weight (rest animals)))]
))
Thanks again, all of your answers helped me to get here!