Re: indirect assignement in lisp

[Pascal Bourguignon]

help-gnu-emacs@vsbe.com writes:

> Hello all,
>
> say I want to assign a variable a value.

Yes, but you need also to learn some more lisp.

> ====================================================
> (defvar marked-point-1 nil )
> (defvar marked-point-2 nil )
>
> (defun set-mark-point ()
>     (interactive)
>     ( let ( point-name ( cmd-key last-command-char ) )
>         ( if ( or ( < cmd-key 49 ) ( > cmd-key 50 ) )
>             ( message "the key is %d how did you get here?" cmd-key )
>             ( progn
>               ( setq point-name ( concat "marked-point-" (number-to-string (- 
> cmd-key 48 ))))
> ;              ( set (eval point-name) (list (current-buffer) (point) ) )
>             )
>         )
>     )
> )
> ===============================================================

First, indenting:

(defun set-mark-point ()
  (interactive)
  (let (point-name (cmd-key last-command-char))
    (if (or (< cmd-key 49) (> cmd-key 50))
        (message "the key is %d how did you get here?" cmd-key)
        (progn
          (setq point-name (concat "marked-point-"
                                   (number-to-string (- cmd-key 48))))
          (set (eval point-name) (list (current-buffer) (point)))))))

Your let is confusing, we might think that you made an error. If you
put each variable on it's line and don't mix the two forms, it'll be
clearer.  Also, I usually put non-initialized variables after the
initialized ones:

(defun set-mark-point ()
  (interactive)
  (let ((cmd-key last-command-char)
        (point-name))
    (if (or (< cmd-key 49) (> cmd-key 50))
        (message "the key is %d how did you get here?" cmd-key)
        (progn
          (setq point-name (concat "marked-point-"
                                   (number-to-string (- cmd-key 48))))
          (set (eval point-name) (list (current-buffer) (point)))))))


It is better for readability to always use the only one dirrection for
comparizon operators. Use only < <= , never > >=.

        (or (< cmd-key 49) (< 50 cmd-key))

is easier to read than:

        (or (< cmd-key 49) (> cmd-key 50))

and:
        (and (<= 49 cmd-key) (<= cmd-key 50))

[ in Common Lisp one could even write: (<= 49 cmd-key 50) ]

of course the above and is the negated form of the above or, so we
have to change the order of the if branches:



(defun set-mark-point ()
  (interactive)
  (let ((cmd-key last-command-char)
        (point-name))
    (if (and (<= 49 cmd-key) (<= cmd-key 50))
        (progn
          (setq point-name (concat "marked-point-"
                                   (number-to-string (- cmd-key 48))))
          (set (eval point-name) (list (current-buffer) (point))))
        (message "the key is %d how did you get here?" cmd-key))))


Since cmd-key is a character, you should use character literals
instead of codes ?a ?b ?1 ?2, etc.
Instead of concat + number-to-string, it's easier to use format.
Variable names are symbols thought, so you must intern the variable
name (a string) to get a symbol.
Finally, you can get at the value of the symbol with symbol-value:


(defun set-mark-point ()
  (interactive)
  (let ((cmd-key last-command-char)
        (point-name))
    (if (and (<= ?1 cmd-key) (<= cmd-key ?2))
        (progn
          (setq point-name (intern (format "marked-point-%c" cmd-key)))
          (setf (symbol-value point-name) (list (current-buffer) (point))))
        (message "the key is %c how did you get here?" cmd-key))))


You can also move bind point-name in a let* since its expression use
the value of the previously set cmd-key, and use error instead of message
to break out of the function in case of error.

(defun set-mark-point ()
  (interactive)
  (let* ((cmd-key last-command-char)
         (point-name (if (and (<= ?1 cmd-key) (<= cmd-key ?2))
                       (intern (format "marked-point-%c" cmd-key))
                       (error "the key is %c how did you get here?" cmd-key))))
      (setf (symbol-value point-name) (list (current-buffer) (point)))
      (message "%S = %S" point-name  (symbol-value point-name))))




Another solution would be to use something like:

(defvar marked-points (make-hash-table))
(defvar valid-keys "12")

(defun set-mark-point ()
  (interactive)
  (let ((cmd-key last-command-char))
     (unless (position cmd-key valid-keys)
        (error "the key is %c how did you get here?" cmd-key))
     (setf (gethash cmd-key marked-points) (list (current-buffer) (point)))
     (message "marked-point %S = %S" cmd-key (gethash cmd-key marked-points))))

with the advantage that you can easily add new marked-points.


-- 
__Pascal Bourguignon__                     http://www.informatimago.com/

ATTENTION: Despite any other listing of product contents found
herein, the consumer is advised that, in actuality, this product
consists of 99.9999999999% empty space.