Tukukkk

Is it possible to write the scheme function symtab below?

(define x 1)

(define y 2)

(symtab x) ; => (x . 1)

(symtab y) ; => (y . 2)

If it isn't possible, can a similar function be defined which has quoted arguments?

(symtab 'x) ; => (x . 1)

(symtab 'y) ; => (y . 2)

It's possible with quoted arguments:

(define (symtab s)

  (cons s (eval s (interaction-environment))))

Now lets test it:

(define xy 12)



(symtab 'xy)

=> (xy . 12)

EDIT: However it's not very reliable (using macro too) - please read closely related Why isn't there an unquote Lisp primitive?

It's because Scheme like most languages is lexically scoped. It means that variable names are resolved when function is defined, as opposed to dynamic scope when variable names are resolved at run-time. So

(define xy 12)



(define (getXY) xy)



(getXY)

=> 12

This code works, because when we define getXY, name xy is known and can be resolved to top-level xy. However

(define (getXY) xy)



(let ((xy 21))

  (getXY))

=> Unbound variable: xy

This doesn't work, because when getXY was defined, xy was not known (and my Guile Scheme also gave me warning when defining getXY "warning: possibly unbound variable `xy'").

It will work in Emacs Lisp - dynamically scoped.

Yes, with macros.

> (define-syntax symtab

  (syntax-rules ()

    ((_ x)

     (cons 'x x))))



> (define x 1)

> (define y 2)

> (symtab x) 

'(x . 1)

> (symtab y)

'(y . 2)

> 

A macro is not actually a function (so technically the essential answer to your question is no). With mere functions your task might even be impossible in most languages. But Scheme provides us with macros that allow us to manipulate a program from within itself. For more on macros and how they are different from functions I recommend taking a look at the following tutorial: http://www.greghendershott.com/fear-of-macros/all.html#%28part..Transform%29

It is based on Racket, but it is substantially applicable across various Scheme dialects. Enjoy!