anchor.diff:  (defpackage :shcl/core/environment
     (:use
      :common-lisp :shcl/core/utility :shcl/core/posix :shcl/core/shell-environment)
  -  (:import-from :shcl/core/sequence #:head #:tail #:empty-p #:walk)
  +  (:import-from :shcl/core/sequence
  +   #:immutable-cons #:empty-immutable-list #:lazy-sequence)
     (:import-from :shcl/core/data #:define-data #:define-cloning-setf-expander)
     (:import-from :fset)
     (:export
  
positive.code: result is processed recursively.  Note that the empty string is
  considered to be an empty list."
    (when (zerop (length string))
      (return-from split-colon-list nil))
  
    (let* ((position (position #\: string))
           (head-stream (make-string-output-stream))
           (tail (when position
                   (make-array (- (length string) (1+ position))
                               :element-type (array-element-type string)
                               :displaced-to string
                               :displaced-index-offset (1+ position)))))
      (loop :for index :below (or position (length string)) :do
        (write-char (aref string index) head-stream))
      (make-colon-list-sequence :head (get-output-stream-string head-stream)
                                :tail tail)))
  
  (defmacro define-environment-accessor (sym-and-name &body options)
    "Define a symbol macro that accesses the given environment
  
negative.code:         (not (not value)))
    value)
  
  (defun split-colon-list (string)
    "This function interprets `string' as a #\: delimited list and
  returns a sequence containing the elements of that list.
  