Programmatically creating functions

Programmatically creating functions

[Ian Eure]

So, I have a list of symbols:

'(foo bar baz)

I want to iterate over the list and create a function from each which  
does something like this:

(defun call-foo ()
   (interactive)
   (invoke-stuff 'foo)

How can I accomplish this? I can't figure out how to create the  
function. I've tried a number of approaches, but have not met with  
success.

  - eval'ing the defun. Returns a function symbol, but I can't call  
it. Maybe it's only created within the scope of the (eval) and not  
callable from outside?

  - Creating a symbol and using fset to assign a lambda to it's  
function cell. It sort of works, but I'm unclear on how to pass a  
variable function name to defun, nor am I clear on how I can make sure  
it calls invoke-stuff with the right symbol.

Help?

  - Ian

Re: Programmatically creating functions

[aartist]

Do you think that skeleton or macro can help?

On Oct 21, 1:26 pm, Ian Eure <i...@digg.com> wrote:
> So, I have a list of symbols:
>
> '(foo bar baz)
>
> I want to iterate over the list and create a function from each which  
> does something like this:
>
> (defun call-foo ()
>    (interactive)
>    (invoke-stuff 'foo)
>
> How can I accomplish this? I can't figure out how to create the  
> function. I've tried a number of approaches, but have not met with  
> success.
>
>   - eval'ing the defun. Returns a function symbol, but I can't call  
> it. Maybe it's only created within the scope of the (eval) and not  
> callable from outside?
>
>   - Creating a symbol and using fset to assign a lambda to it's  
> function cell. It sort of works, but I'm unclear on how to pass a  
> variable function name to defun, nor am I clear on how I can make sure  
> it calls invoke-stuff with the right symbol.
>
> Help?
>
>   - Ian

Re: Programmatically creating functions

[Joost Diepenmaat]

Ian Eure <ian@digg.com> writes:

> So, I have a list of symbols:
>
> '(foo bar baz)
>
> I want to iterate over the list and create a function from each which
> does something like this:
>
> (defun call-foo ()
>   (interactive)
>   (invoke-stuff 'foo)
>
> How can I accomplish this? I can't figure out how to create the
> function. I've tried a number of approaches, but have not met with
> success.
>
>  - eval'ing the defun. Returns a function symbol, but I can't call
> it. Maybe it's only created within the scope of the (eval) and not
> callable from outside?
>
>  - Creating a symbol and using fset to assign a lambda to it's
> function cell. It sort of works, but I'm unclear on how to pass a
> variable function name to defun, nor am I clear on how I can make sure
> it calls invoke-stuff with the right symbol.

I'm not /quite/ sure where you've got problems, but in this case elisp's
lack of closures hurts. IMHO the simplest way to get what you want is to
use a macro:

(defmacro make-caller-macro (symbol) 
  `(defun ,(intern (concat "call-" (symbol-name symbol))) () 
     (,symbol)))

But that won't evaluate the argument, so you'd more or less have to use
eval as well:

(dolist (s '(foo bar)) (eval `(make-caller-macro ,s)))

-- 
Joost Diepenmaat | blog: http://joost.zeekat.nl/ | work: http://zeekat.nl/

Re: Programmatically creating functions

[Andreas Politz]

Joost Diepenmaat wrote:
> Ian Eure <ian@digg.com> writes:
> 
>> So, I have a list of symbols:
>>
>> '(foo bar baz)
>>
>> I want to iterate over the list and create a function from each which
>> does something like this:
>>
>> (defun call-foo ()
>>   (interactive)
>>   (invoke-stuff 'foo)
>>
>> How can I accomplish this? I can't figure out how to create the
>> function. I've tried a number of approaches, but have not met with
>> success.
>>
>>  - eval'ing the defun. Returns a function symbol, but I can't call
>> it. Maybe it's only created within the scope of the (eval) and not
>> callable from outside?
>>
>>  - Creating a symbol and using fset to assign a lambda to it's
>> function cell. It sort of works, but I'm unclear on how to pass a
>> variable function name to defun, nor am I clear on how I can make sure
>> it calls invoke-stuff with the right symbol.
> 
> I'm not /quite/ sure where you've got problems, but in this case elisp's
> lack of closures hurts. IMHO the simplest way to get what you want is to
> use a macro:
> 
> (defmacro make-caller-macro (symbol) 
>   `(defun ,(intern (concat "call-" (symbol-name symbol))) () 
>      (,symbol)))
> 
> But that won't evaluate the argument, so you'd more or less have to use
> eval as well:
> 
> (dolist (s '(foo bar)) (eval `(make-caller-macro ,s)))
> 


Does this work ? (in general)

(defun make-fun (name)
   (fset (intern (format "call-%s" name))
	`(lambda nil
	   ,(format "call-%s is a very good function." name)
	   (interactive)
	   (message "I was once %s" (quote ,name)))))

(mapcar 'make-fun '(foo bar baz))
(describe-function 'call-baz)
(call-bar)

-ap

Re: Programmatically creating functions

[Ian Eure]

On Oct 21, 2008, at 11:57 AM, Andreas Politz wrote:

> Joost Diepenmaat wrote:
>> Ian Eure <ian@digg.com> writes:
>>> So, I have a list of symbols:
>>>
>>> '(foo bar baz)
>>>
>>> I want to iterate over the list and create a function from each  
>>> which
>>> does something like this:
>>>
>>> (defun call-foo ()
>>>  (interactive)
>>>  (invoke-stuff 'foo)
>>>
>>> How can I accomplish this? I can't figure out how to create the
>>> function. I've tried a number of approaches, but have not met with
>>> success.
>>>
>>> - eval'ing the defun. Returns a function symbol, but I can't call
>>> it. Maybe it's only created within the scope of the (eval) and not
>>> callable from outside?
>>>
>>> - Creating a symbol and using fset to assign a lambda to it's
>>> function cell. It sort of works, but I'm unclear on how to pass a
>>> variable function name to defun, nor am I clear on how I can make  
>>> sure
>>> it calls invoke-stuff with the right symbol.
>> I'm not /quite/ sure where you've got problems, but in this case  
>> elisp's
>> lack of closures hurts. IMHO the simplest way to get what you want  
>> is to
>> use a macro:
>> (defmacro make-caller-macro (symbol)   `(defun ,(intern (concat  
>> "call-" (symbol-name symbol))) ()      (,symbol)))
>> But that won't evaluate the argument, so you'd more or less have to  
>> use
>> eval as well:
>> (dolist (s '(foo bar)) (eval `(make-caller-macro ,s)))
>
>
> Does this work ? (in general)
>
Yes, with a little hacking, it works:

(defvar sql-connection-alist
   '((poola
      (sql-product 'mysql)
      (sql-server "pool-a")
      (sql-user "me")
      (sql-password "mypass")
      (sql-database "default")
      (sql-port 3306))
     (poolb
      (sql-product 'mysql)
      (sql-server "pool-b")
      (sql-user "me")
      (sql-password "mypass")
      (sql-database "default")
      (sql-port 3307)))
   "AList of preset connections for `sql-connect-preset'.")

(defun sql-connect-preset (name)
   "Connect to a predefined SQL connection listed in `sql-connection- 
alist'"
   (require 'sql)
   (let ((conn (cdr (assoc name sql-connection-alist)))
         (sql-name (symbol-name name)))
     (eval `(let ,conn
              (flet ((sql-get-login (&rest what)))
                (sql-product-interactive sql-product))))))

(defun sql-convenience ()
   (interactive)
   (mapcar (lambda (conn)
             (let ((name (car conn)))
               (fset (intern (format "sql-%s" name))
                     `(lambda nil
                        ,(format "Connect to %s SQL preset." name)
                        (interactive)
                        (sql-connect-preset ',name)))))
           sql-connection-alist))

So now I can define preset connections and get sql-* methods to invoke  
them directly.

Thank you for the help.

  - Ian

Re: Programmatically creating functions

[Emil]

On Oct 25, 11:28 am, Ian Eure <i...@digg.com> wrote:
> On Oct 21, 2008, at 11:57 AM, Andreas Politz wrote:
>
>
>
> > Joost Diepenmaat wrote:
> >> Ian Eure <i...@digg.com> writes:
> >>> So, I have a list of symbols:
>
> >>> '(foo bar baz)
>
> >>> I want to iterate over the list and create a function from each  
> >>> which
> >>> does something like this:
>
> >>> (defun call-foo ()
> >>>  (interactive)
> >>>  (invoke-stuff 'foo)
>
> >>> How can I accomplish this? I can't figure out how to create the
> >>> function. I've tried a number of approaches, but have not met with
> >>> success.
>
> >>> - eval'ing the defun. Returns a function symbol, but I can't call
> >>> it. Maybe it's only created within the scope of the (eval) and not
> >>> callable from outside?
>
> >>> - Creating a symbol and using fset to assign a lambda to it's
> >>> function cell. It sort of works, but I'm unclear on how to pass a
> >>> variable function name to defun, nor am I clear on how I can make  
> >>> sure
> >>> it calls invoke-stuff with the right symbol.
> >> I'm not /quite/ sure where you've got problems, but in this case  
> >> elisp's
> >> lack of closures hurts. IMHO the simplest way to get what you want  
> >> is to
> >> use a macro:
> >> (defmacro make-caller-macro (symbol)   `(defun ,(intern (concat  
> >> "call-" (symbol-name symbol))) ()      (,symbol)))
> >> But that won't evaluate the argument, so you'd more or less have to  
> >> use
> >> eval as well:
> >> (dolist (s '(foo bar)) (eval `(make-caller-macro ,s)))
>
> > Does this work ? (in general)
>
> Yes, with a little hacking, it works:
>
> (defvar sql-connection-alist
>    '((poola
>       (sql-product 'mysql)
>       (sql-server "pool-a")
>       (sql-user "me")
>       (sql-password "mypass")
>       (sql-database "default")
>       (sql-port 3306))
>      (poolb
>       (sql-product 'mysql)
>       (sql-server "pool-b")
>       (sql-user "me")
>       (sql-password "mypass")
>       (sql-database "default")
>       (sql-port 3307)))
>    "AList of preset connections for `sql-connect-preset'.")
>
> (defun sql-connect-preset (name)
>    "Connect to a predefined SQL connection listed in `sql-connection-
> alist'"
>    (require 'sql)
>    (let ((conn (cdr (assoc name sql-connection-alist)))
>          (sql-name (symbol-name name)))
>      (eval `(let ,conn
>               (flet ((sql-get-login (&rest what)))
>                 (sql-product-interactive sql-product))))))
>
> (defun sql-convenience ()
>    (interactive)
>    (mapcar (lambda (conn)
>              (let ((name (car conn)))
>                (fset (intern (format "sql-%s" name))
>                      `(lambda nil
>                         ,(format "Connect to %s SQL preset." name)
>                         (interactive)
>                         (sql-connect-preset ',name)))))
>            sql-connection-alist))
>
> So now I can define preset connections and get sql-* methods to invoke  
> them directly.


Here is another attempt  I wrote recently :

(setq sql-connection-alist
      '((local
         (sql-product 'mysql)
         (sql-server "<server>")
         (sql-user "<user>")
         (sql-password "<password>")
         (sql-database "<database>")
         (sql-port 3306))
        (qa
         (sql-product 'mysql)
         (sql-server "<server>")
         (sql-user "<user>")
         (sql-password "<password>")
         (sql-database "<database>")
         (sql-port 3306))))

(defun sql-connect-preset (name)
  "Connect to a predefined SQL connection listed in `sql-connection-
alist'"
  (eval `(let ,(cdr (assoc name sql-connection-alist))
    (flet ((sql-get-login (&rest what)))
      (sql-product-interactive sql-product)))))

;; iterate over the alist and create functions
(mapcar '(lambda(x)
	   (let ((ds-name (symbol-name x)))
	     (eval (car (read-from-string
			 (format "(defun sql-%s()  (interactive) (sql-connect-preset '%s))"
ds-name ds-name))))))
	(mapcar 'car sql-connection-alist))

(provide 'mysql-utils)


Require mysql-utils and it i becomes available as M-x sql-local, or M-
x sql-qa.

emil