gentle | Simple yet powerful and really beautiful application | Blog library

You can use datetime.strptime to turn a string into a datetime object, then datetime.strftime to reformat it into a different string.

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:

list.filter((dev, age) => dev[age].includes(oldest)) doesn't make sense because age is not an outer variable, but a plain property - and the value is a number, not an array, so .includes won't work. I'd use Math.max to first identify the highest age, then filter by the objects with that age.

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.

The book is wrong.

With this small change however, the answer from the book works again:

When you enter the form (fact-debugging 4) in the REPL, the form is evaluated using eval, hence: 5: (EVAL (FACT-DEBUGGING 4)).

If you move the emacs point to EVAL in 5 and press M-. (using Slime), you will find that eval is calling eval-in-lexenv, which is itself calling simple-eval-in-lexenv, hence: 4: (SB-INT:SIMPLE-EVAL-IN-LEXENV (FACT-DEBUGGING 4) #).

If you move the point to the 4th frame and press ENTER, you will see something like this:

Unfortunately, while coping and yaking I forgot to change the recursive calls on atoms-to-q-no-null. I realized this error while preparing this question for stackoverflow.

Since I had already written some part of the question, I thought it would be better to answer it and make the effort useful for other people.

After fixing the recursive calls of the function: