[pro] substitution macro lisp extension?
Is there any well-known implementation of a macro similar to old Lisp Machine's defsubst, but not as fancy, one that simply emits a macro after doing a reasonable, if less than perfect, attempt to do substitutions and guarantee first-to-last arg once-and-once-only evaluation? I realize that most people just use declare inline for this kind of thing. Or define a macro like defsubst just to emit a defun with a declare-inline declaration. I would like something that's different: something that always emits a macro def given a function-like semantics for args and body. It's a pretty simple thing, but I was wondering if it's sitting around in a library somewhere. What's out there? Thanks, Mark
On Sep 21, 2010, at 10:48, Mark H. David wrote:
Is there any well-known implementation of a macro similar to old Lisp Machine's defsubst, but not as fancy, one that simply emits a macro after doing a reasonable, if less than perfect, attempt to do substitutions and guarantee first-to-last arg once-and-once-only evaluation?
I realize that most people just use declare inline for this kind of thing. Or define a macro like defsubst just to emit a defun with a declare-inline declaration. I would like something that's different: something that always emits a macro def given a function- like semantics for args and body.
It's a pretty simple thing, but I was wondering if it's sitting around in a library somewhere. What's out there?
Isn't this what symbol-macrolet, macrolet, and define-compiler-macro are for? Dr. David McClain Chief Technical Officer Refined Audiometrics Laboratory 4391 N. Camino Ferreo Tucson, AZ 85750 email: dbm@refined-audiometrics.com phone: 1.520.390.3995 web: http://refined-audiometrics.com
How is this different from using an "inline" declaration? Mark H. David wrote:
Is there any well-known implementation of a macro similar to old Lisp Machine's defsubst, but not as fancy, one that simply emits a macro after doing a reasonable, if less than perfect, attempt to do substitutions and guarantee first-to-last arg once-and-once-only evaluation?
I realize that most people just use declare inline for this kind of thing. Or define a macro like defsubst just to emit a defun with a declare-inline declaration. I would like something that's different: something that always emits a macro def given a function-like semantics for args and body.
It's a pretty simple thing, but I was wondering if it's sitting around in a library somewhere. What's out there?
Thanks,
Mark
_______________________________________________ pro mailing list pro@common-lisp.net http://common-lisp.net/cgi-bin/mailman/listinfo/pro
On Wed, Sep 22, 2010 at 17:18, Daniel Weinreb <dlw@itasoftware.com> wrote:
How is this different from using an "inline" declaration?
Some compilers ignore inline declarations. With defsubst, you are not at the mercy of the compiler. I have used defsubst (Allegro CL has it) in places where I was absolutely sure that inlining was the right thing to do. Then again, Allegro CL had me do that because it ignores inline declarations, so the whole thing may be a non-issue with other compilers. -Hans
This is different from inlining in that does not generate a function. You cannot funcall the defined symbol, just use it as a macro. Call sites always macro-expand. I don't really care about or want to really get into a discussion of what compilers do or not, or whether this is "useful" or not. Just wondering if this is some available functionality. E.g., is the Allegro thing contributed to the world, or just proprietary? Thanks, Mark Hans Hübner wrote:
How is this different from using an "inline" declaration? Some compilers ignore inline declarations. With defsubst, you are not at the mercy of the compiler. I have used defsubst (Allegro CL has it) in places where I was absolutely sure that inlining was the right
On Wed, Sep 22, 2010 at 17:18, Daniel Weinreb<dlw@itasoftware.com> wrote: thing to do. Then again, Allegro CL had me do that because it ignores inline declarations, so the whole thing may be a non-issue with other compilers.
-Hans
On Wed, Sep 22, 2010 at 17:32, Mark H. David <mhd@yv.org> wrote:
This is different from inlining in that does not generate a function. You cannot funcall the defined symbol, just use it as a macro. Call sites always macro-expand. I don't really care about or want to really get into a discussion of what compilers do or not, or whether this is "useful" or not. Just wondering if this is some available functionality. E.g., is the Allegro thing contributed to the world, or just proprietary?
The Allegro CL defsubst is not open source, it is not even part of the documented ACL API. I am not aware of any open source implementations, but I'd be interested. -Hans
Can someone show an example of this defsubst in use? I'm not sure I understand what it's for. -Peter On Wed, Sep 22, 2010 at 9:08 AM, Hans Hübner <hans.huebner@gmail.com> wrote:
On Wed, Sep 22, 2010 at 17:32, Mark H. David <mhd@yv.org> wrote:
This is different from inlining in that does not generate a function. You cannot funcall the defined symbol, just use it as a macro. Call sites always macro-expand. I don't really care about or want to really get into a discussion of what compilers do or not, or whether this is "useful" or not. Just wondering if this is some available functionality. E.g., is the Allegro thing contributed to the world, or just proprietary?
The Allegro CL defsubst is not open source, it is not even part of the documented ACL API. I am not aware of any open source implementations, but I'd be interested.
-Hans
_______________________________________________ pro mailing list pro@common-lisp.net http://common-lisp.net/cgi-bin/mailman/listinfo/pro
-- Peter Seibel http://www.codequarterly.com/
On 22 September 2010 19:16, Peter Seibel <peter@gigamonkeys.com> wrote:
Can someone show an example of this defsubst in use? I'm not sure I understand what it's for.
To the best of my understanding it has two effects: 1. it allows reliable inlining on compilers that do not respect inline declarations. 2. it allows the expansion to utilize the lexical context of the call site. Consider: (defmacro foo () :global) (declaim (inline bar1)) (defun bar1 () (foo)) (defsubst bar2 () (foo)) (macrolet ((foo () :local)) (values (bar1) (bar2))) => :GLOBAL, :LOCAL Cheers, -- Nikodemus
On Wed, 22 Sep 2010 17:24:33 +0200, Hans Hübner <hans.huebner@gmail.com> wrote:
On Wed, Sep 22, 2010 at 17:18, Daniel Weinreb <dlw@itasoftware.com> wrote:
How is this different from using an "inline" declaration?
Some compilers ignore inline declarations. With defsubst, you are not at the mercy of the compiler. I have used defsubst (Allegro CL has it) in places where I was absolutely sure that inlining was the right thing to do.
This all reminds me of the old lkml glory: http://markmail.org/message/uaegqp4xznxupctd The "inline_me_harder" one is my personal favorite. -- regards, Samium Gromoff -- "Actually I made up the term 'object-oriented', and I can tell you I did not have C++ in mind." - Alan Kay (OOPSLA 1997 Keynote)
participants (7)
-
Daniel Weinreb -
David McClain -
Hans Hübner -
Mark H. David -
Nikodemus Siivola -
Peter Seibel -
Samium Gromoff