cdr | Static site generator for making web mixtapes | Static Site Generator library

Yes, your double lambda approach does work. But there are nicer ways to do this too.

It turns out define can do this directly. The following two pieces of code are identical:

You are modifying list but not returning it.

Here is what you need to do:

Any function that accepts a single argument and returns a list will do. Here's a variation of the function you used to demonstrate map.

When you are doing the SICP problems, it would be most beneficial if you strive to adhere to the spirit of the question. You can determine the spirit from the context: the topics covered till the point you are in the book, any helper code given, the terminology used etc. Specifically, avoid using parts of the scheme language that have not yet been introduced; the focus is not on whether you can solve the problem, it is on how you solve it. If you have been provided helper code, try to use it to the extent you can.

SICP has a way of building complexity; it does not introduce a concept unless it has presented enough motivation and justification for it. The underlying theme of the book is simplification through abstraction, and in this particular section you are introduced to various higher order procedures -- abstractions like accumulate, map, filter, flatmap which operate on sequences/lists, to make your code more structured, compact and ultimately easier to reason about.

As illustrated in the opening of this section, you could very well avoid the use of such higher programming constructs and still have programs that run fine, but their (liberal) use results in more structured, readable, top-down style code. It draws parallels from the design of signal processing systems, and shows how we can take inspiration from it to add structure to our code: using procedures like map, filter etc. compartmentalize our code's logic, not only making it look more hygienic but also more comprehensible.

If you prematurely use techniques which don't come until later in the book, you will be missing out on many key learnings which the authors intend for you from the present section. You need to shed the urge to think in an imperative way. Using set! is not a good way to do things in scheme, until it is. SICP forces you down a 'difficult' path by making you think in a functional manner for a reason -- it is for making your thinking (and code) elegant and 'clean'.

Just imagine how much more difficult it would be to reason about code which generates a tree recursive process, wherein each (child) function call is mutating the parameters of the function. Also, as I mentioned in the comments, assignment places additional burden upon the programmers (and on those who read their code) by making the order of the expressions have a bearing on the results of the computation, so it is harder to verify that the code does what is intended.

Edit: I just wanted to add a couple of points which I feel would add a bit more insight:

1. Your code using set! is not wrong (or even very inelegant), it is just that in doing so, you are being very explicit in telling what you are doing. Iteration also reduces the elegance a bit in addition to being bottom up -- it is generally harder to think bottom up.
2. I feel that teaching to do things recursively where possible is one of the aims of the book. You will find that recursion is a crucial technique, the use of which is inevitable throughout the book. For instance, in chapter 4, you will be writing evaluators (interpreters) where the authors evaluate the expressions recursively. Even much earlier, in section 2.3, there is the symbolic differentiation problem which is also an exercise in recursive evaluation of expressions. So even though you solved the problem imperatively (using set!, begin) and bottom-up iteration the first time, it is not the right way, as far as the problem statement is concerned.

Having said all this, here is my code for this problem (for all the structure and readability imparted by FP, comments are still indispensable):

You have a reasonable-looking sequence of if tests (though using cond instead would be more idiomatic Scheme). But the values you return do not generally look correct.

The first problem I see is in your first if clause. If both trees are empty, you return '(). But according to the spec, you should be calling the succ function with that result. This may look unimportant if you use id as your continuation, but note that each recursive step builds up a more detailed succ continuation, so in general succ may be a quite impactful function.

The second if is also a problem. Again you return '(), when you are supposed to return the first conflicting subtrees. It's not clear to me what that means, but it would be reasonable to pass a pair of tree1 and tree2 to fail.

The third and fourth clause look fine. You call succ with a pair of the two leaves, as expected.

The recursive call is clearly wrong: you have mis-parenthesized calls to cons, and your lambda variable is named X but you refer to it as x. The series of cons calls doesn't really look right either, but you can experiment with that once your more pressing syntactic issues are resolved and your base cases work properly.

Lastly, you are doing a lot of low-level work with cons, car, '(), and so on. You should be using the abstract functions provided to you, such as add-subtree and (make-tree), instead of using the low-level primitives they are built on.

I have solved this now and I needed to add the line this.measuredSelected = latest; into the if block. I am assuming that this is because I have two way binding in the html as when debugging I noticed that the value of measuredSelected is already set.

In lisps the list is a fundamental data structure, and it is comprised of pairs. Traditionally, the first member of the pair is called its car, and the second member is called its cdr:

( car . cdr )

Here the dot indicates that the pair is composed of two cells. Given a pair, (a . b), the accessor for the first member is also called car, and the accessor for the second member is called cdr. So:

(car '(a . b)) --> a, and
(cdr '(a . b)) --> b.

To form a list, pairs are combined in the following way: the first member of the first pair is the first element of the list, and the second member of the first pair is either the empty list or a pair representing the rest of the list. So, a list of one element, e.g., (a) is represented by the pair (a . ()).

A list of two elements, e.g., (a b) is represented by the pair (a . (b . ())). Here, the second member of the first pair is the pair (b . ()). You will note that the cdr of the list (a b) is the list (b), or equivalently (b . ()).

A list of three elements, e.g., (a b c) is similarly represented as (a . (b . (c . ()))). A list is a pair which has either the empty list () or a pair in its cdr. There is a distinction to be made here about proper lists (the final pair must have a () in its cdr) and improper lists, but I will ignore that distinction here. And the empty list is also a list (but not a pair). To make things a bit more precise: in Scheme a list is either the empty list or a pair whose cdr is a list.

So, car gets the first member of a list, and cdr gets the rest of the list. Given the list (a b c d) we can see that:

(cdr '(a b c d)) --> (b c d), and
(cdr (cdr '(a b c d))) --> (cdr '(b c d)) --> (c d), and
(car (cdr (cdr '(a b c d)))) --> (car (cdr '(b c d))) --> (car '(c d)) --> c.

So, given the definition:

The point is about how parameters to functions are passed in Common Lisp. They are passed by value. This means that, when a function is called, all arguments are evaluated, and their values are assigned to new, local variables, the parameters of the function. So, consider your function:

The test for null car doesn’t do any good, cdr will return nil before car does.

You need a base case where you find you’re done and return something instead of recursing. Right now you don’t have that. Look at examples of simple recursive functions and see how they have a base case.

To count the elements in a list there are two cases:

The base case where the list is empty (return 0)

The recursive case where the list isn’t empty (return 1 + the count of the cdr of the passed in list)