How do I name a variable after a string in Lisp? - lisp

Question

I'd like to rename a variable in Lisp, and use a pre-existing string for the renaming. I.e. if my string is "abc" I'd like Lisp to take the string and make it the name of my variable. Any ideas?
Thank you!

Answer 1

Based on your comment:
Here's what I'm trying to do: 1. I'm writing a parser for a new language. 2. Part of the language involves creating variables and naming them. 3. So, the user enters: name:contents -- where name is the name of the variable and contents is what the variable contains. 4. I'd like to know how to take the name input that the user provides, and tell Lisp to create a variable and call it name
You almost certainly do not want to use Lisp variables for whatever your embedded language is. Instead the usual thing to do in this case is to define some kind of 'environment' object which carries around a mapping between variable names and values in the language you are implementing. Typically you want the following operations on it.
Is a variable bound in an environment?
Retrieve the value of a bound variable from an environment.
Modify the value of a bound variable in an environment.
Extend an environment with one or more new bindings, returning a new environment.
And perhaps add a binding to an environment, without constructing a new environment.
If you can get away without the last one then that's generally good, as it will make the semantics of your language easier to understand and errors in programs easier to catch, as you can't assign to unbound variables.
A classic (but slow in some cases) example of an implementation of an environment structure is an association list. This easily supports the first three, but does not really support the last easily.
Here is an example which assumes variables are named by strings (so you don't need to intern symbols for them):
(defconstant empty-environment '())
(defun variable-bound-in-environment-p (env var)
(if (assoc var env :test #'string=) t nil))
(defun variable-value-in-environment (env var)
(let ((binding (assoc var env :test #'string=)))
(unless binding
(error "unbound"))
(cdr binding)))
(defun (setf variable-value-in-environment) (new env var)
(let ((binding (assoc var env :test #'string=)))
(unless binding
(error "unbound"))
(setf (cdr binding) new)))
(defun extend-environment (env &rest vars/vals)
(labels ((ee-loop (e vvp)
(if (null vvp)
e
(destructuring-bind (var val . more) vvp
(ee-loop (acons var val e) more)))))
(ee-loop env vars/vals)))
Now:
> (variable-bound-in-environment-p empty-environment "foo")
nil
> (variable-value-in-environment
(extend-environment empty-environment "foo" 1)
"foo")
1
> (variable-value-in-environment
(extend-environment
(extend-environment empty-environment "foo" 1)
"foo" 2)
"foo")
2
> (variable-value-in-environment
(let ((e (extend-environment empty-environment "foo" 1)))
(setf (variable-value-in-environment e "foo") 2)
e)
"foo")
2
You may want to use Lisp symbols for variable names, which will make variable lookup etc in environments a little faster and nicer. For these purposes symbols are simply strings with identity. To do this you need to take the strings you get as variable names and 'intern' them to create symbols. A good approach to this is to keep these symbols in their own namespace, which Common Lisp calls a 'package', rather than smashing the namespace that the underlying Lisp program uses:
(defvar *language-package* (make-package "LANGUAGE-PACKAGE" :use '()))
(defun intern-language-variable-name (s &optional (package *language-package*))
(intern s package))
And now you can be sure that
> (eq (intern-language-variable-name "foo")
(intern-language-variable-name "foo"))
t
And then you can, after getting the stringy versions of variable names from your parser, intern them using intern-language-variable-name and then use these objects in your environment, which can thus be a little faster and simpler:
(defconstant empty-environment '())
(defun variable-bound-in-environment-p (env var)
(if (assoc var env) t nil))
(defun variable-value-in-environment (env var)
(let ((binding (assoc var env)))
(unless binding
(error "unbound"))
(cdr binding)))
(defun (setf variable-value-in-environment) (new env var)
(let ((binding (assoc var env)))
(unless binding
(error "unbound"))
(setf (cdr binding) new)))
(defun extend-environment (env &rest vars/vals)
(labels ((ee-loop (e vvp)
(if (null vvp)
e
(destructuring-bind (var val . more) vvp
(ee-loop (acons var val e) more)))))
(ee-loop env vars/vals)))