parametrized function definition

parametrized function definition

[Joe Bloggs]

Hi, I am trying to write a function that allows me to quickly bind a key combination
to insert arbitrary text:

(defun set-local-key-insert ()
  "set a local key to insert some text"
  (interactive)
  (let (keystring textinsert) 
    (setq keystring (read-key-sequence "Key combination to bind: "))
    (setq textinsert (read-string "Text to insert: "))
    (local-set-key (read-kbd-macro keystring) (lambda () (interactive) (insert textinsert)))
    )
  )

However, this doesn't work since textinsert is not evaluated until the function is called with the keybinding. How can I get this to work properly? I am new to elisp so I imagine it's very simple.

Thanks.

Re: parametrized function definition

[Lennart Borgman (gmail)]

Joe Bloggs wrote:
> Hi, I am trying to write a function that allows me to quickly bind a key combination
> to insert arbitrary text:
> 
> (defun set-local-key-insert ()
>   "set a local key to insert some text"
>   (interactive)
>   (let (keystring textinsert) 
>     (setq keystring (read-key-sequence "Key combination to bind: "))
>     (setq textinsert (read-string "Text to insert: "))
>     (local-set-key (read-kbd-macro keystring) (lambda () (interactive) (insert textinsert)))
>     )
>   )
> 
> However, this doesn't work since textinsert is not evaluated until the function is called with the keybinding. How can I get this to work properly? I am new to elisp so I imagine it's very simple.

You can remove textinsert from let and make it a defvar instead.

   (defvar textinsert nil)

Re: parametrized function definition

[Thien-Thi Nguyen]

() "Lennart Borgman (gmail)" <lennart.borgman@gmail.com>
() Wed, 09 Jul 2008 09:06:30 +0200

   > (defun set-local-key-insert ()
   >   "set a local key to insert some text"
   >   (interactive)
   >   (let (keystring textinsert)   
   >     (setq keystring (read-key-sequence "Key combination to bind: "))
   >        (setq textinsert (read-string "Text to insert: "))
   >        (local-set-key (read-kbd-macro keystring) 
   >                       (lambda () (interactive) 
   >                         (insert textinsert)))))

   You can remove textinsert from let and make it a defvar instead.

     (defvar textinsert nil)

Yes, but that would defeat the presumed intention of using `textinsert'
as a local variable.  Practically, this means `set-local-key-insert'
invocations clobber previous invocations' state (last invocation wins).

Probably OP wants `lexical-let'.

thi

Re: parametrized function definition

[Lennart Borgman (gmail)]

Thien-Thi Nguyen wrote:
> () "Lennart Borgman (gmail)" <lennart.borgman@gmail.com>
> () Wed, 09 Jul 2008 09:06:30 +0200
> 
>    > (defun set-local-key-insert ()
>    >   "set a local key to insert some text"
>    >   (interactive)
>    >   (let (keystring textinsert)   
>    >     (setq keystring (read-key-sequence "Key combination to bind: "))
>    >        (setq textinsert (read-string "Text to insert: "))
>    >        (local-set-key (read-kbd-macro keystring) 
>    >                       (lambda () (interactive) 
>    >                         (insert textinsert)))))
> 
>    You can remove textinsert from let and make it a defvar instead.
> 
>      (defvar textinsert nil)
> 
> Yes, but that would defeat the presumed intention of using `textinsert'
> as a local variable.  Practically, this means `set-local-key-insert'
> invocations clobber previous invocations' state (last invocation wins).
> 
> Probably OP wants `lexical-let'.
> 
> thi

Then maybe this page is helpful:

   http://www.emacswiki.org/cgi-bin/wiki/FakeClosures

Re: parametrized function definition

[Xah]

On Jul 8, 10:07 am, Joe Bloggs <w...@cares.invalid> wrote:
> Hi, I am trying to write a function that allows me to quickly bind a key combination
> to insert arbitrary text:
>
> (defun set-local-key-insert ()
>   "set a local key to insert some text"
>   (interactive)
>   (let (keystring textinsert)
>     (setq keystring (read-key-sequence "Key combination to bind: "))
>     (setq textinsert (read-string "Text to insert: "))
>     (local-set-key (read-kbd-macro keystring) (lambda () (interactive) (insert textinsert)))
>     )
>   )
>
> However, this doesn't work since textinsert is not evaluated until the function is called with the keybinding. How can I get this to work properly? I am new to elisp so I imagine it's very simple.

Perhaps just the function “eval”?

  Xah
∑ http://xahlee.org/

☄

Re: parametrized function definition

[Joel J. Adamson]

Joe Bloggs <who@cares.invalid> writes:

> Hi, I am trying to write a function that allows me to quickly bind a key combination
> to insert arbitrary text:

You mean like a keyboard macro?  C-x ( t e x t t h a t y o u w a n t t o
i n s e r t C-x ), then C-x e to insert the text.

You can also create macros of arbitrary keyboard movements, not just
text insertion.  Right now I'm defining a keyboard macro to insert this
text.

C-x e
=>
Right now I'm defining a keyboard macro to insert this text.

Joel
-- 
Joel J. Adamson
(303) 880-3109
Public key: http://pgp.mit.edu
http://www.unc.edu/~adamsonj
http://trashbird1240.blogspot.com

Re: parametrized function definition

[weber]

On Jul 8, 2:07 pm, Joe Bloggs <w...@cares.invalid> wrote:
> Hi, I am trying to write a function that allows me to quickly bind a key combination
> to insert arbitrary text:
>
> (defun set-local-key-insert ()
>   "set a local key to insert some text"
>   (interactive)
>   (let (keystring textinsert)
>     (setq keystring (read-key-sequence "Key combination to bind: "))
>     (setq textinsert (read-string "Text to insert: "))
>     (local-set-key (read-kbd-macro keystring) (lambda () (interactive) (insert textinsert)))
>     )
>   )
>
> However, this doesn't work since textinsert is not evaluated until the function is called with the keybinding. How can I get this to work properly? I am new to elisp so I imagine it's very simple.
>
> Thanks.

Hi Joe.

You have to use some special syntax to that textinsert is evaluated
(so your lambda will insert the contents of textinsert, and not the
symbol textinsert)
I also rewrote your let, because it looks nicer this way, but you can
keep the setqs you if want :)

(defun set-local-key-insert ()
  "set a local key to insert some text"
  (interactive)
  (let ((keystring (read-key-sequence "Key combination to bind: "))
	(textinsert (read-string "Text to insert: ")))
    (local-set-key (read-kbd-macro keystring) `(lambda ()
(interactive) (insert ,textinsert)))))

The significant changes are the backquote before the lambda, and the
comma before textinsert.
Take a look at the help for this function with C-h f `

HTH
weber

Re: parametrized function definition

[Joe Bloggs]

Thien-Thi Nguyen <ttn@gnuvola.org> writes:

> () "Lennart Borgman (gmail)" <lennart.borgman@gmail.com>
> () Wed, 09 Jul 2008 09:06:30 +0200
>
>    > (defun set-local-key-insert ()
>    >   "set a local key to insert some text"
>    >   (interactive)
>    >   (let (keystring textinsert)   
>    >     (setq keystring (read-key-sequence "Key combination to bind: "))
>    >        (setq textinsert (read-string "Text to insert: "))
>    >        (local-set-key (read-kbd-macro keystring) 
>    >                       (lambda () (interactive) 
>    >                         (insert textinsert)))))
>
>    You can remove textinsert from let and make it a defvar instead.
>
>      (defvar textinsert nil)
>
> Yes, but that would defeat the presumed intention of using `textinsert'
> as a local variable.  Practically, this means `set-local-key-insert'
> invocations clobber previous invocations' state (last invocation wins).
>
> Probably OP wants `lexical-let'.
>
> thi

lexical-let did the job, thanks: 

(require 'cl)
(defun set-local-key-insert ()
  "set a local key to insert some text"
  (interactive)
  (let (keystring) 
    (setq keystring (read-key-sequence "Key combination to bind: "))
    (lexical-let (textinsert)
      (setq textinsert (read-string "Text to insert: "))
      (local-set-key (read-kbd-macro keystring) (lambda () (interactive) (insert textinsert)))
      )
    )
  )

Re: parametrized function definition

[Joe Bloggs]

adamsonj@email.unc.edu (Joel J. Adamson) writes:

> Joe Bloggs <who@cares.invalid> writes:
>
>> Hi, I am trying to write a function that allows me to quickly bind a key combination
>> to insert arbitrary text:
>
> You mean like a keyboard macro?  C-x ( t e x t t h a t y o u w a n t t o
> i n s e r t C-x ), then C-x e to insert the text.
>
> You can also create macros of arbitrary keyboard movements, not just
> text insertion.  Right now I'm defining a keyboard macro to insert this
> text.
>
> C-x e
> =>
> Right now I'm defining a keyboard macro to insert this text.
>
> Joel
> -- 
> Joel J. Adamson
> (303) 880-3109
> Public key: http://pgp.mit.edu
> http://www.unc.edu/~adamsonj
> http://trashbird1240.blogspot.com

The problem with macros is that if I have several of them then several keys presses
are required to access each one. I prefer to have simple two-finger key combinations.

Re: parametrized function definition

[Joe Bloggs]

weber <hugows@gmail.com> writes:

> On Jul 8, 2:07 pm, Joe Bloggs <w...@cares.invalid> wrote:
>> Hi, I am trying to write a function that allows me to quickly bind a key combination
>> to insert arbitrary text:
>>
>> (defun set-local-key-insert ()
>>   "set a local key to insert some text"
>>   (interactive)
>>   (let (keystring textinsert)
>>     (setq keystring (read-key-sequence "Key combination to bind: "))
>>     (setq textinsert (read-string "Text to insert: "))
>>     (local-set-key (read-kbd-macro keystring) (lambda () (interactive) (insert textinsert)))
>>     )
>>   )
>>
>> However, this doesn't work since textinsert is not evaluated until the function is called with the keybinding. How can I get this to work properly? I am new to elisp so I imagine it's very simple.
>>
>> Thanks.
>
> Hi Joe.
>
> You have to use some special syntax to that textinsert is evaluated
> (so your lambda will insert the contents of textinsert, and not the
> symbol textinsert)
> I also rewrote your let, because it looks nicer this way, but you can
> keep the setqs you if want :)
>
> (defun set-local-key-insert ()
>   "set a local key to insert some text"
>   (interactive)
>   (let ((keystring (read-key-sequence "Key combination to bind: "))
> 	(textinsert (read-string "Text to insert: ")))
>     (local-set-key (read-kbd-macro keystring) `(lambda ()
> (interactive) (insert ,textinsert)))))
>
> The significant changes are the backquote before the lambda, and the
> comma before textinsert.
> Take a look at the help for this function with C-h f `
>
> HTH
> weber

Thanks alot weber, this is the best solution I received.