slime | Slime is an efficient , redundant object storage system

The problem is here:

In the standard library, the end iterator is one place past the end of the container. To be compatible with the standard library, your end() method should be:

You pass an entire Dummy to the predicate function when you call pred((curr -> data). pred, coming from the line dummy1 = dummy1.filter(teeth_list, &func);, is a function expecting an int, which it doesn't get.

There are a couple of potential fixes.

1. Use a function that expects a Dummy (and extracts the teeth itself ;-) ).
2. Pass the number of teeth (which are currently inaccessible), not the entire Dummy.
3. Providing a conversion operator to int in Dummy (presumably returning the number of teeth) should work as well.

The conversion operator approach seemed to work for me. I inserted

Ok, so this is a fun one. Have a look here:

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:

If you navigate to the top frame in the debugger and press enter on that frame, you will see that commission is not known to the debugger as a local variable:

1. Yes, by default, within Slime I don't think this works.

2. It will work within the SBCL Repl:

Package HISTORY-TREE does not exist

That message is clear: the package HISTORY-TREE does not exist. But you try to read symbols into this non-existent package, for example HISTORY-TREE:OWNER.

Every package which is mentioned in a printed symbol in that file needs to exist, before one can successfully read the file.

The default Common Lisp reader does not create packages on the fly by just reading symbols.

Example:

Yes, there are good reasons. In Racket, we have define

In an internal-definition context, a define form introduces a local binding; see Internal Definitions. A the top level, the top-level binding for id is created after evaluating expr

So, as you said, a define in a local context (such as a function body) defines a local function, with access to the enclosing variables and which only exists during that function.

Now compare that to Common Lisp's defun

Defines a new function named function-name in the global environment.

So, regardless of where a defun appears, it always defines a name at the global scope, with no access to local variables and with a name that becomes globally available. So your suggestion for a nested defun is really equivalent to defining the defun at the top-level (in the sense that the name is available at the top-level and in the sense that local variables are inaccessible), except that the name doesn't exist until you've called the original function at least once, which is, frankly, fairly unintuitive behavior.

Incidentally, the labels approach is the thing you want. In Common Lisp, if we want local helper functions, we use flet (for non-recursive functions) or labels (for recursive functions).

As to why this is, Common Lisp tries to enforce a very clear variable scope at all times. In any function, local variables are introduced with (let ...) and only exist inside of the block, and local functions are introduced with (flet ...) and (labels ...). Racket has similar constructs but also allows the more Scheme-like paradigm (Racket is a Scheme dialect, after all) of using define to define local variables for the rest of the current scope, similar to how you'd do it in more imperative languages.