anchor.diff:          (invoke f env (cdr expression))
           (error "Not an operator: ~A." f))))
   
  -(defun lookup (symbol env)
  -  (if (consp env)
  -      (if (eq (caar env) symbol)
  -          (cdar env)
  -          (lookup symbol (cdr env)))
  +(defun lookup (symbol &optional (env *global-env*))
  +  (if env
  +      (or (gethash symbol (env-bindings env))
  +          (lookup symbol (env-parent env)))
         (error "No binding for ~A." symbol)))
   
   (defun (setf lookup) (new-value symbol env)
  -  (if (consp env)
  -      (if (eq (caar env) symbol)
  -          (setf (cdr (car env)) new-value)
  -          (setf (lookup symbol (cdr env)) new-value))
  +  (if env
  +      (if (gethash symbol (env-bindings env))
  +          (setf (gethash symbol (env-bindings env)) new-value)
  +          (setf (lookup symbol (env-parent env)) new-value))
         (error "No binding for ~A." symbol)))
   
  -(defun extend (env variables values)
  -  (cond ((consp variables)
  -         (if (consp values)
  -             (cons (cons (car variables) (car values))
  -                   (extend env (cdr variables) (cdr values)))
  -             (error "Not enough values.")))
  -        ((null variables)
  -         (if (null values)
  -             env
  -             (error "Too many values.")))
  -        ((symbolp variables)
  -         (cons (cons variables values) env))))
  +(defun extend (env symbol value)
  +  (if (nth-value 1 (gethash symbol (env-bindings env)))
  +      (warn "Redefinition of ~A." symbol))
  +  (setf (gethash symbol (env-bindings env)) value))
  +
  +(defun make-child-env (env variables values)
  +  (make-env :parent env
  +            :bindings (loop :for name :in variables
  +                            :for binding :in values
  +                            :with table = (make-hash-table :test 'eq)
  +                            :do (setf (gethash name table) binding)
  +                            :finally (return table))))
   
   (defvar *denv* nil)
   (defstruct clutter-operator function)
  
positive.code:   (make-clutter-operator 
     :function
     (lambda (*denv* values)
       (let ((env (extend env variables values)))
         (loop for sexp in body
            for last-value = (clutter-eval sexp env)
            finally (return last-value))))))
  
negative.code: 
  (defpackage #:fexpr-clutter (:use :cl :alexandria))
  (in-package #:fexpr-clutter)
  
  (defstruct env
    parent bindings)
  
  (defun clutter-eval (expression environment)
    (cond ((symbolp expression) (eval/symbol expression environment))
  