anchor.diff:  (in-package :ia-hash-table)
   
  -(defun get-deep-hash (ht keys)
  -  (let ((value ht))
  -    (loop for (key . nullable) in keys do
  -             (setf value (gethash key value))
  -             (when (and (null value) (alexandria:ends-with #\? key))
  -               (return)))
  -    value))
  +;; (defun get-deep-hash (ht keys)
  +;;   (let ((value ht))
  +;;     (loop for (key . nullable) in keys do
  +;;              (setf value (gethash key value))
  +;;              (when (and (null value) (alexandria:ends-with #\? key))
  +;;                (return)))
  +;;     value))
   
   (defun have-nullable-p (keys)
     (loop for (key . nullable) in keys
           if nullable
           return t))
   
  +(defun safe-aref (vector index)
  +  (if (or (< index 0)
  +          (>= index (length vector)))
  +      nil
  +      (elt vector index)))
  +
   (defun gen-get-deep-hash-nullables (ht keys)
     (alexandria:with-gensyms (block-name value)
       `(block ,block-name
          (let ((,value ,ht))
            ,(let ((form ht)) 
  -            (loop for (key . nullable) in keys do
  +            (loop for ((type . key) . nullable) in keys do
                        (setf form (if nullable
  -                                    `(progn
  -                                       (setf ,value (gethash ,key ,form))
  -                                       (unless ,value
  -                                         (return-from ,block-name))
  -                                       ,value)
  -                                    `(setf ,value (gethash ,key ,form)))))
  +                                    (ecase type
  +                                      (:elt
  +                                       `(progn
  +                                          (setf ,value (safe-aref ,form ,key))
  +                                          (unless ,value
  +                                            (return-from ,block-name))
  +                                          ,value))
  +                                      (:key
  +                                       `(progn
  +                                          (setf ,value (gethash ,key ,form))
  +                                          (unless ,value
  +                                            (return-from ,block-name))
  +                                          ,value)))
  +                                    (ecase type
  +                                      (:key
  +                                       `(setf ,value (gethash ,key ,form)))
  +                                      (:elt
  +                                       `(setf ,value (elt ,form ,key)))))))
               form)
            ,value))))
   
   (defun gen-get-deep-hash-w/o-nullables (ht keys)
     (let ((form ht)) 
  -     (loop for (key . nullable) in keys do
  -              (setf form `(gethash ,key ,form)))
  +    (loop for ((type . key) . nullable) in keys do
  +             (ecase type
  +               (:key
  +                (setf form `(gethash ,key ,form)))
  +               (:elt
  +                (setf form `(elt ,form ,key)))))
        form))
   
   (defun gen-get-deep-hash (ht keys)
  
positive.code:       (gen-get-deep-hash-nullables ht keys)
        (gen-get-deep-hash-w/o-nullables ht keys)))
  
  (defun process-?. (keys)
    (loop for key in keys 
          if (alexandria:ends-with #\? key)
          collect (cons (subseq key 0 (1- (length key))) t)
          else
          collect (cons key nil)))
  
  (defun ia-syntax-reader (stream char arg)
    (declare (ignorable char arg))
  
negative.code:     (assert (symbolp symbol) nil "IA-syntax: ~a is not a symbol" symbol)
      (destructuring-bind (var-name &rest raw-keys)
          (split-sequence:split-sequence #\. (string symbol) :remove-empty-subseqs t)
        (destructuring-bind (((type . var-name) . nullable)) (process-?. (list var-name))
          (assert (eql :key type))
          (let ((var-symbol (intern var-name *package*))
                (keys (process-?. raw-keys)))
            (if nullable
  