Please add 'cl-with'

[stacksmith]

https://github.com/stacksmith/cl-with

WITH- is a universal macro that:

• allows grouping of any with- style macros (to avoid deep indentation)
• uniformly manages structs, classes and CFFI objects
• unifies the syntax binding single and multiple values

Thank you

[phoe]

Random question: what are its selling points over https://gitlab.common-lisp.net/with-contexts/with-contexts ?

[stacksmith]

I've never used the above library, but it appears that its goal is to emulate the Python's dynamic context support, focusing on controlling the dynamic state within the introduced scope.

The goal of cl-with is (mostly) to create lexical bindings en-masse, combining - lets, multiple-value-binds, slot binders of structs and classes, and slots of foreign objects

The really interesting use of this macro is its ability to deal with CFFI foreign objects and slots. It can use existing :OLD foreign objects, create :TEMP ones and delete them, or create a :NEW object with a longer extent. It can rebind foreign slot names into the current package, optionally prefixing them or changing them entirely.

(with- (p   :temp :int)                              ; like with-foreign-object
       (gpt :temp (:struct gtk:g-point) "P1-")       ; prefixed: p1-x and p1-y 
       (spt :old 'q:spoint "P2-")                    ; existing instance, p2-x etc.
       (ppp :new 'graphics:point (h hor)(v ver))     ; rename graphics::hor to h, etc.
  (setf p1-x p2-x              ;note that bindings are package-local!
        p1-y p2-y)             ;and prefixed to differentiate multiple objects
  (setf h (+ p1-x p2-x)
        v (- p1-x 3))
  ppp) 

[guicho271828]

That is a simple and neat idea. Perhaps the only complaint I may have is why there is a trailing hyphen in it?
Another question is how is it detecting where the clauses stop without an additional parenthesis? If it is looking up a macro function with the same name, it might become a source of a bug.

[stacksmith]

Thanks. I had another macro called with and chose with- because it kind of makes sense - it mates with any existing with- style macro (by prefixing keyword with with- ). So, (with- (:open-file...)) expands to (with-open-file ...)

As for the second question... I think I was sloppy with examples. There are two possibilities:

• a single clause followed by &body, or
• a (list of clauses) followed by &body
  I will try to fix the errors and clarify that.

Just to be clear - my main goal was to be able to effortlessly bind to foreign structures. Working with large CFFI apis can drive you crazy, especially when you have to deal with hundreds of CFFI structures, each with a number of symbols for slots. This macro silently discovers slot names and rebinds them locally, with the ability to prefix bindings to disambiguate them. And create temporary structures - all on one short line.

The ability to do everything else was pretty much free, and worked so well that I kept it. It was not my goal to create a universal binding macro (I've seen a few attempts that look ok but are cumbersome).

[guicho271828]

Well IMHO the structuring and binding is a realm of pattern matching, so the cffi binding part is better be handled by pattern matchers, but since I don't know the utility of the temporal structure and the rebinding, there's probably something I don't understand yet.
Anyways the overall idea is cool thank you very much

[stacksmith]

You are likely correct about binding being somehow related to pattern matching, although I haven't seen a really clear paradigm outside of linear text. Structured data has several extra dimensions to consider, and looking at macro lambda-lists (probably the most sophisticated destructuring/binding mechanism in common use) and their limitations, you can see that it is not obvious how to take apart arbitrary structures and wrangle them into a different form...
I am humbly trying to avoid extreme indentation and bulk when establishing a comfy lexical environment with all the bindings I need. This macro covers a lot of ground, has zero runtime overhead, and it's pretty intuitive to use.
Thanks for your support.

[guicho271828]

To clarify, just destructing a C/CFFI object is already made available in https://github.com/guicho271828/trivia/wiki/Contrib-packages#triviacffi . However, since I don't understand the "temporal structure" and "rebinding" that the library offers and I don't want to overstate something, I stop here.

[stacksmith]

CFFI itself supports destructuring, but usually I don't want to destructure the entire foreign object - just access some slots...

By rebinding I mean binding symbols in the current package even though the foreign structure is in some other package, for the duration of the with- clause.

I don't know where "temporal structure" came from... I think I mentioned temporary structures meaning foreign objects that live for the duration of the clause. I simply added :new, :old, and :temp keywords to allows creation of new objects, usage of existing ones, or creation of temporary objects.

[guicho271828]

I don't want to destructure the entire foreign object
This gave me a bit of doubt about whether you understand the meaning of destructuring in the CL context. Because this sentence does not make sense. You likely confusing it with the idea of freeing (destructor in C++). Destruct != Deconstruct. Edit: I misremembered a bit

[guicho271828]

In the proper CL terminology your temporary objects are foreign pointer objects with dynamic extent. Look for the clhs entry for the "extent".

[guicho271828]

Finally rebinding doesn't seem like anything special from making a new binding with let. So that's well within the pattern matcher's territory

[stacksmith]

Now we are getting into nitpicking territory, and I do not wish to have a fight.

I simply tried to explain things you repeatedly stated to 'not understand' about the library, in an increasingly simplified, conversational manner. Largely because your wording was a bit sloppy and you misquoted me.

Nothing about with- is 'anything special' - it is a convenience library providing syntactic sugar. You are free to use let if you wish or use with-foreign-slots and package:slotname if it appeals to you. It is much easier to specify :temp rather than :foreign-pointer-with-dynamic-extent. And it's probably not worth talking about destructuring of foreign objects at this point, as I am feeling particularly post-covid stupid...

Best wishes.