From: Pedro Kroger
Subject: parsing lambda lists
Date: 
Message-ID: <2641c5d4-8e41-4798-b54f-234d2efd8bba@o4g2000pra.googlegroups.com>
Hi,

I remember someone posted a library to parse lambda lists some time
ago, but I can't find it. ("parsing lambda lists" is not the most
googlebe term). Does anyone knows where I can find it?

Pedro
From: Brian
Subject: Re: parsing lambda lists
Date: 
Message-ID: <c47fc43e-01c2-442a-8e6a-e1e63a89347c@b38g2000prf.googlegroups.com>
On Nov 13, 3:45 pm, Pedro Kroger <············@gmail.com> wrote:
> Hi,
>
> I remember someone posted a library to parse lambda lists some time
> ago, but I can't find it. ("parsing lambda lists" is not the most
> googlebe term). Does anyone knows where I can find it?
>
> Pedro
Alexandria has a function to do that.
From: budden
Subject: Re: parsing lambda lists
Date: 
Message-ID: <1b59a68c-6117-4dc3-b9c3-7074106668f3@k1g2000prb.googlegroups.com>
1. Many libraries (e.g. iterate, screamer) contain portable code
walkers.
All they seem to be based on some common code. Your implementation
might contain
the one too. Try

(apropos "walk-arglist")

2. Swank package might contain somenting useful
3. clocc/src/port/sys.lisp contains arglist function which returns
an arglist of an existing function. This might help too.
From: Pedro Kroger
Subject: Re: parsing lambda lists
Date: 
Message-ID: <9ac2762f-efca-43e0-92d7-d568847fcb07@a3g2000prm.googlegroups.com>
Thank you guys, that's what I was looking for.

Pedro
From: Pascal J. Bourguignon
Subject: Re: parsing lambda lists
Date: 
Message-ID: <87wsf7qibk.fsf@hubble.informatimago.com>
Pedro Kroger <············@gmail.com> writes:
> I remember someone posted a library to parse lambda lists some time
> ago, but I can't find it. ("parsing lambda lists" is not the most
> googlebe term). Does anyone knows where I can find it?

There are several, but I only remember the url of mine.  Sorry.
You'll have to google the others.

Try: http://darcs.informatimago.com/public/lisp/common-lisp/source-form.lisp

Here's an example of usage:

(eval-when (:compile-toplevel :load-toplevel :execute)
  (shadow '(DEFUN DEFGENERIC DEFMETHOD)))


(defparameter *call-stack* '())


(cl:defmacro defun (name args &body body)
  (let ((lambda-list (parse-lambda-list args :ordinary))
        (docu (extract-documentation body))
        (decl (extract-declarations  body))
        (body (extract-body          body)))
    `(cl:defun ,name ,args
       ,@(when docu (list docu))
       ,@decl
       (push (list ',name ,@(make-argument-list lambda-list)) *call-stack*)
       (multiple-value-prog1 (progn ,@body)
         (pop *call-stack*)))))


(cl:defmacro defmethod (name &rest stuff)
  (let* ((qualifiers (extract-method-qualifiers stuff))
         (args       (extract-method-lambda-list     stuff))
         (lambda-list     (parse-lambda-list args :specialized))
         (docu       (extract-method-documentation stuff))
         (decl       (extract-method-declarations  stuff))
         (body       (extract-method-body          stuff)))
    `(cl:defmethod
         ,name ,@qualifiers ,args
         ,@(when docu (list docu))
         ,@decl
         (push (list ',name ,@(make-argument-list lambda-list)) *call-stack*)
         (multiple-value-prog1 (progn ,@body)
           (pop *call-stack*)))))

(cl:defmacro defgeneric (name args &rest options-and-methods)
  `(cl:defgeneric ,name ,args
     ,@(mapcar
        (lambda (item)
          (if (and (consp item) (eq :method (car item)))
              (let* ((stuff      (rest item))
                     (qualifiers (extract-method-qualifiers stuff))
                     (args       (extract-method-lambda-list     stuff))
                     (lambda-list     (parse-lambda-list args :specialized))
                     (docu       (extract-method-documentation stuff))
                     (decl       (extract-method-declarations  stuff))
                     (body       (extract-method-body          stuff)))
                `(:method ,@qualifiers ,args
                          ,@(when docu (list docu))
                          ,@decl
                          (push (list ',name ,@(make-argument-list lambda-list))
                                *call-stack*)
                          (multiple-value-prog1 (progn ,@body)
                            (pop *call-stack*))))
              item))
        options-and-methods)))


-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
From: Rob Warnock
Subject: Re: parsing lambda lists
Date: 
Message-ID: <YpudnR9HL_5eG4DUnZ2dnUVZ_ofinZ2d@speakeasy.net>
Pedro Kroger  <············@gmail.com> wrote:
+---------------
| I remember someone posted a library to parse lambda lists some time
| ago, but I can't find it. ("parsing lambda lists" is not the most
| googlebe term). Does anyone knows where I can find it?
+---------------

Not prepackaged as a library, but Henry Baker's META parsing macro:

    http://home.pipeline.com/~hbaker1/Prag-Parse.html

gives a PARSE-LAMBDA-EXP for Common Lisp in an appendix. And:

    http://www.cliki.net/meta

points to downloadable versions of Baker's META.


-Rob

-----
Rob Warnock			<····@rpw3.org>
627 26th Avenue			<URL:http://rpw3.org/>
San Mateo, CA 94403		(650)572-2607
comp.lang.lisp / 2008 / nov