The treap, aka what people should learn instead of red black trees (because they're a lot simpler with similar performance).

How are fingerprint's supposed to be generated? Just another hash?

essentially, yes.

Hey man, writing bindings for Vacietis so you can call clx as XLib right now :)

That's not really equivalent to what Rebol does or what my stuff does. What do you do when you want to unbind msg? Or when you want to carry around your bindings with you and change them through function calls?

If you wanted to unbind msg, you wouldn't have bound it in a let block.

If you wanted to carry around your bindings with you and change them through function calls, you'd probably use a special variable.

Meh, not necessarily. Lazy by default gives you a lot of good stuff. We shouldn't assume that macros can't be done better anyway.

It is very hard to reason about the laziness, unfortunately, so it is more of a beautiful hack most often rather than a sustainable design methodology. While with macros you've got a very simple, reproducible, verifiable design methodology for constructing arbitrarily complex DSLs.

So this was a very interesting post. I would like to note that we can actually do something like definitional scoping in CL too :), but we need to write it ourselves!

We would do this using CLOS and its MOP, more precisely by using the FUNCALLABLE metaclass and having a class with an environment slot, source slot and effective function slot which both would be altered by some convention (USE, COMPOSE and FUNCTION it seems?).

Then you'd SET-FUNCALLABLE-INSTANCE-FUNCTION to a lambda that invalidates the efficient function when source or environment has changed and composes a new function with (compile `(let((,@environment(( ,@source)).

Voila, you now have a type of function that carries with it an environment and its source code.

Now I don't know if this fully satisfies what REDBOL is doing to be honest, because the post talks about "deep walking" and that sounds like code walking, which is a scary place to go to in CL.

EDIT: Yeah, it seems like USE would do a full code walk(?) Code walking really sucks, because you need to recognise the special forms of CL and deal with them appropriately. This doesn't apply if the list of vars used is always passed to USE (just let LET take over binding the lexical environment)

I have tried to use SBCL's code walker on a pet project and so far I have no problem with it; in fact it is surprisingly easy to use. By the way, the following post is a good introduction to it: http://christophe.rhodes.io/notes/blog/posts/2014/naive_vs_p...

More like: If possible, then don't define a macro. You should use macros as much as possible.

> More like: If possible, then don't define a macro. You should use macros as much as possible.

Are your two sentences intentionally opposite?