promethial / paxedit

Structured, Context-Driven, LISP Editing and Refactoring

Geek Repo:Geek Repo

Github PK Tool:Github PK Tool

paxedit-delete/paxedit-kill behaving different than advertised

mfiano opened this issue · comments

The manual states:

(setf x 1
      y -!-2
      g 3)

;;; ->

(setf x 1
      g 3)

...however the behavior I see is:

(setf x 1
      y -!-2
      g 3)

;;; ->

-!-

I see this may be due to the code lacking paxedit-implicit-functions-common-lisp :/

@mfiano, your observation that Paxedit doesn't have a listing of Common Lisp implicit functions, specifically in the paxedit-implicit-functions-common-lisp is spot on, and the reason why running delete/kill functionality in setf for example kills to top-level expression.

I'll be adding a paxedit-implicit-functions-common-lisp to the next version of Paxedit, which I'm targeting for release later today.

Paxedit v1.1.8 is up with support for Common Lisp implicit functions. The list of implicit functions is not exhaustive—specified in paxedit-implicit-functions-common-lisp—and needs to be expanded.

Additionally, it may not have been clear in the documentation but the language support was
only Emacs Lisp and Clojure—primarily because these are the only LISP languages that I use rather than a limitation of Paxedit itself. It's fairly straight forward to extend Paxedit to handle any other LISP e.g. Common Lisp. All that said, not being a regular Common Lisp user, suggestions and contributions to Paxedit Common Lisp support are welcome.

@promethial Excellent, thanks. What irked me a bit was that implicit functions are defined in specific variables per language, rather than something a bit more extendable (though I'm not exactly sure the best way to handle it, not being familiar much at all with Emacs Lisp). In any case, thanks for the quick fix.

Glad it worked.

Implicit functions had to be at the language level since Emacs Lisp and Common Lisp overlap for certain functions (e.g. setf, setq), but that's about where the overlap ends and the differences begin (e.g. Clojure has implicit structures like maps). The idea is the variables enable extendability, by enabling users to add/subtract their own implicit functions.