anchor.diff:        (gen-get-deep-hash-nullables ht keys)
         (gen-get-deep-hash-w/o-nullables ht keys)))
   
  +(defun process-elt-key (key)
  +  (let ((integer (ignore-errors (parse-integer key))))
  +    (or integer
  +        (intern key *package*))))
  +
  +(defun parse-key (key)
  +  (if (and (eql (aref key 0) #\[)
  +           (eql (aref key (1- (length key))) #\]))
  +    (cons :elt (process-elt-key (subseq key 1 (1- (length key)))))
  +    (cons :key key)))
  +
   (defun process-?. (keys)
     (loop for key in keys 
           if (alexandria:ends-with #\? key)
  -        collect (cons (subseq key 0 (1- (length key))) t)
  +        collect (cons (parse-key (subseq key 0 (1- (length key)))) t)
           else
  -        collect (cons key nil)))
  +        collect (cons (parse-key key) nil)))
   
   (defun ia-syntax-reader (stream char arg)
     (declare (ignorable char arg))
  
positive.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 ((var-name . nullable)) (process-?. (list var-name))
          (let ((var-symbol (intern var-name *package*))
                (keys (process-?. raw-keys)))
            (if nullable
  
negative.code: (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 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 ((type . key) . nullable) in keys do
                       (setf form (if nullable
                                      (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 ((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)
  