Question

I am attempting to evaluate a literal as an expression in Scheme (using Guile currently). Example:

(define x '(+ 6 6))
(define y (evaluate-literal x))     ; Expected result:  y = 12

(Here, evaluate-literal is a placeholder for what I’m looking for.) Is there a lisp function/idiom that allows this to be done? The reason why I need to do this is because the expression may be invalid at the time of definition, but would be a valid expression later when it is evaluated.

---

Currently my workaround solution is to use delay and force but it’s not very elegant:

(define x (delay (+ 6 6)))
(define y (force x))

Answer 1

The simplest way would be to use eval, although difficult to use safely. See this post to see the reasons why.

(define x '(+ 6 6))
(define y (eval x))

Using the built-in delay/force procedures is a fine solution:

(define x (delay (+ 6 6)))
(define y (force x))

Or, as has been suggested in the comments, you could use a lambda for implementing your own delay/force syntax:

(define-syntax my-delay
  (syntax-rules ()
    ((my-delay object)
     (lambda () object))))

(define (my-force delayed-object)
  (delayed-object))

(define x (my-delay (+ 6 6)))
(define y (my-force x))

The above is a toy implementation, a real-world implementation would memoize the result for avoiding the need to call the lambda each time, but you get the idea.