anchor.diff:  
   )
   
  +;; --------------------
  +
  +
  +(defun mk-iterable-macro-function (iterable)
  +  ;; easy enough to produce, may be non-trivial to bind for "Normal Evaluation"
  +  (with-symbols (args environment
  +                      s whence returnv forms)
  +    (let* ((memb (simple-vector-iterable-members iterable))
  +           (typ (array-element-type memb)))
  +    `(lambda (,args ,environment)
  +       ;; TBD WITH-ENV (PORTABLY)
  +       ;; For now, although this is probably not actually good - even when
  +       ;; the compiler produces this behavior after DEFMACRO
  +       (declare (ignore ,environment))
  +       (destructuring-bind ((,s &optional ,returnv) &rest ,forms) ,args
  +         (with-symbols ( %memb %len %n)
  +           `(let* ((,%memb ,,memb)
  +                   (,%len ,,(length memb)))
  +              (dotimes (,%n ,%len ,,returnv)
  +                (let ((,,s (svref ,%memb ,%n)))
  +                  (declare (type ,,typ ,,s))
  +                  ,@,forms
  +                  )))))))))
  +
  +#+NIL
  +(eval-when ()
  +  (defparameter *v* (make-simple-vector-iterable '(1 2 3)))
  +
  +
  +  (defparameter *f* (mk-iterable-macro-function  *v*))
  +  (defparameter *expr*
  +    '((elt (values call-reg t))
  +      (npushl (expt %elt 2) call-reg)))
  +
  +
  +  (funcall (coerce *f* 'function) *expr* nil)
  +
  +  ;;   (defmacro frob-iter ( ;; HOWTO / TBD
  +
  +)
  +
  +;; ------------------------------
   
   
   (defstruct (list-iterable
  
positive.code: ;;------------------------------------------------------------------------------
  
  (defpackage #:ltp/common/iter
    (:use #:ltp/common #:cl))
  
  
  (in-package #:ltp/common/iter)
  
negative.code: #+TBD
  (defmacro do-list-iterable ((s whence &optional returnv) &body forms)
    )
  
  ;; ------------------------------------------------------------
  
  (defclass iterable-class (standard-class)
    ((member-element-type
      :type type-designator
      ;; :access (:read :bind)
      :initarg :member-element-type
      :initform t)))
  
  (defclass iterable-object ()
    ())
  
  (defclass sequence-iterable-object (iterable-object)
    ((members
      :initarg :members
      :type sequence)))
  
  (defclass iterable-vector-class (standard-class)
    ((member-storage-element-type
      :type type-designator
      ;; :access (:read :bind)
      :initarg :member-storage-element-type
      :initform t)))
  
  
  (defclass vector-iterable-object (sequence-iterable-object)
    ((members
      :type (array * (*)))))
  
  (defclass simple-vector-iterable-object (vector-iterable-object)
    ((members
      ;; :access (:read :bind :unbind)
      ;; TD (Trivial Slot Access Protocol)
      ;; SLOT-VALUE-READABLE-P
      ;; SLOT-VALUE-WRITABLE-P
      ;; SLOT-VALUE-BINDABLE-P
      ;; SLOT-VALUE-UNBINDABLE-P
      :type (simple-array * (*)))))
  
  (defclass list-iterable-object (sequence-iterable-object)
    ((members
      :type list)))
  
  
  
  (defgeneric mk-iterable (kind &key &allow-other-keys)
    (:method ((kind vector-iterable-object)
              &key members
                (element-type t) (storage-element-type element-type)
                &allow-other-keys)
      (let* ((len (length members))
             (memb (make-array len
                               :element-kind
                               (storage-element-type (class-of kind))
                               :initial-contents members))
        ;; ... trivial
        ))
    )
  
  
  
  ;; TBD
  ;; ENSURE-STORAGE-USING-CLASS (CLASS ITERABLE &OPTIONAL INITIAL-CONTENTS)
  ;; SHARED-INITIALIZE (ITERABLE T &REST INITARGS &KEY INITIAL-CONTENTS &ALLOW-OTHER-KEY
  ;;
  ;; [Re]Design LTP-Main ENUM onto ITERABLE-CLASS, ITERABLE-OBJECT
  ;; adding functions for storage onto symbolic enumeration member objects
  
  #+ITERABLE-MAP-FUNCTION
  (defgeneric ensure-iterable-map-function (return-type iterable)
  
    ;; TBD: How to effectively parameterize the selection of a per-instance
    ;; static or per-class/instance-dynamic :policy for creation of the iterable
    ;; map function
    ;;    NB: Revise the immediate API => MAP-ITERABLE-STATIC, MAP-ITERABLE-DYNAMIC
    ;;        referring to annotations, subsq.
    ;;
    ;; Note that any map-function being called exactly once may use a
    ;; static policy - it not differing substantially then, to the
    ;; :dynamic call case, in which some forms generally operating on the
    ;; individual iterable object would not be evaluated until the
    ;; function is called. Conceivably, the :static initialized iterator
    ;; function may serve to provide the compiler with an opportunity to
    ;; further optimize the function, in its compilation.
  
    (:method ((return-type t) (iterable simple-vector-iterable))
  
      ;; TBD: Moving the following into a conventional function, e.g
      ;;
      ;; ENSURE-GENERIC-ITERABLE-STATIC-MAP-FUNCTION
      ;; such that may be cached per each instance, under its instance
      ;; values and class state at the time of the function's creation
      ;;
      ;; juxtaposed to a conventional function, e.g
      ;;
      ;; ENSURE-GENERIC-ITERABLE-DYNAMIC-MAP-FUNCTION
      ;; such that may be cached per each class, under that class' state at
      ;; the time of the function's creation
      ;;
      ;; Note that this differentiation may seem somewhat trivial for
      ;; iterable object and iterable class implementations not using
      ;; typed local sequence values for direct storage. Regardless, it
      ;; may be observed that this design may serve to provide an opportunity
      ;; for some optimizations of the compiled forms of functions
      ;; providing support for iterative generalized operations in the
      ;; :static case - while not, per se, preventing applications in the
      ;; :dynamic case
      ;;
      ;; TBD furthermore: Towards concepts of literate programming in a
      ;; system supporting annotation of project resources under an RDF,
      ;; TeX model - e.g using RDF for system reference informatoin, and TeX
      ;; for information pursuant towards presentation in visual
      ;; presentation systems -- if not as an intermediary, direct source
      ;; notation, pursuant to a methodology for deriving XML from
      ;; arbitrary resources annotated with a TeX notation -- moreover for
      ;; audal text-to-speech systems, beyond visual characteristics (per
      ;; se) of graphical resource hyperlinking systems. .... towards
      ;; which, a concept of a model-specific TeX environment may pertain
      ;;
      ;; -- towards generalized usage cases:
      ;;
      ;; - Systems Documentation
      ;; - Systems Review, Analysis, and QA - Support
      ;; - Reusability of Systems - as a singular topic, per se.
      ;;
      ;; ... as may entail some integration with existing source
      ;; documentation systems, e.g gtk-doc, Doxygen, etc.
      ;;
      ;; ... and the presentation environment.
      ;;
      ;; Context: CommonIDE, initially in implementation with generalized
      ;; wigets onto GTK+
  
      (let* ((result-storage (mk-result-form return-type iterable))
             (form
              (with-symbols (fn)
                `(lambda (,fn)
                   (declare (type (function ,fn)))
  
                   ;; NB: :STATIC storage for iterable-members, in this
                   ;; prototype - an initial policy, pursuant of some
                   ;; implicit assumptions with regards to applications
                   ;;
                   ;; also, static storage for the ephemeral result object
                   ;; (such that should not be destructively modified by
                   ;; any calling forms, as it may be reused across
                   ;; subsequent calls to this function)
                   ;;
                   ;; Usage Cases e.g
                   ;;
                   ;; - Iterative operations onto static enumerated type
                   ;;   information - note that the caller-provided
                   ;;   function is not hard coded in the function
                   ;;   returned by the following.
                   ;;
                   ;; - Iterative operations onto static model
                   ;;   information - however generally as may subsume
                   ;;   operations onto enumerated type information - e.g
                   ;;   in applications for static model analysis
  
                   ;; NB: MAP-INTO may seem superfluous if the RESULT-TYPE := NIL
                   ;;
                   ;; The implementation may handle that call-case, implicitly.
  
                   (map-into ,result-storage
                             ;; ^ NB: Static result value storage (may be NIL)
                             ,(with-frob (elt)
                                ;; NB: Additional wrapping for FN - to
                                ;; provide existing information to the
                                ;; compiler, as for the type of the
                                ;; argument provided to the function FN,
                                ;; assuming that the compiler may then be
                                ;; be to provide additional optimizations
                                ;; onto the call to FN itself.
                                `(lambda (,elt)
                                   (declare (type ,elt
                                                  ;; NB: This call would
                                                  ;; be the same, across
                                                  ;; static and dynamic
                                                  ;; policies, as
                                                  ;; annotated :
                                                  ,(iterable-member-storage-element-type
                                                    (class-of iterable))))
                                   (funcall ,fn ,elt)))
                             ;; NB: Static members storage:
                             ,(iterable-members iterable))
                   (values ,result-storage)))))
        (values (compile* form))
  
  ;; TBD - caching for iterable map functions
  ;;       onto {(CLASS-OF ITERABLE), ITERABLE, RETURN-TYPE}
  ;;       - Note static storage of iterable members sequences and result
  ;;         sequences, in the function produced in the example above
  
  ;; TBD: MK-RESULT-FORM
  ;; TBD: MK-RESULT-FORM-USING-CLASS
  
  ;; TBD: ENSURE-ITERABLE-MAP-FUNCTION-USING-CLASS
  
        )))
  
  ;; TBD: Beyond the singular specification of :static or :dynamic policy
  ;; for creation of iterator map functions, this system should endeavor
  ;; to support a broader facilitation of application of arbitrary system
  ;; optimization policies, e.g at scales of
  ;;
  ;;  {project, {source-section, usage-case+}+}
  ;;
  ;; ... for any source section, whether or not implemented in a Common
  ;; Lisp language.
  ;;
  ;; ... presently, regardless of any concept of "Over-Optimization"
  
  
  
  
  (defgeneric map-iterable (fn iterable &key &allow-other-keys)
  
    ;; TBD API => map-iterable-dynamic (fn iterable)
    #-ITERABLE-MAP-FUNCTION ;; NB: Dynamic/Class-Specific Policy here
    (:method ((fn function) (iterable sequence-iterable-object)
              &key return-type &allow-other-keys)
      ;; NB: FN may assume its own element-type for the iterable
      ;;
      ;; NB: Special eval-case of RETURN-TYPE := NIL
      (map return-type fn (iterable-members iterable)))
  
    ;; TBD API => map-iterable-static (fn iterable)
    #+ITERABLE-MAP-FUNCTION
    ;; NB: Static/Instance or Dynamic/Class Policy for Creation and
    ;; Storage of the iterable map function as would be used internally,
    ;; within the following
    ;;
    ;; e.g: compute and apply a function singularly for mapping a function
    ;; onto the iterable's effective member objects - the function may be
    ;; compiled and subsequently cached, under any single manner of
    ;; application policy
    ;;
    ;; Note that the mapped function may exit non-locally.
    ;;
    ;; NB: The iterator function must apply the mapped function in a
    ;; reentrant manner.
    ;;
    ;; NB: Under a static policy, the result returned by the following may
    ;; be stored locally to the iterable-map-function, i.e the iterator
    ;; function and - as such - should not be destructively modified.
    ;;
    (:method ((fn function) (iterable iterable-object)
              &key return-type &allow-other-keys)
      (funcall (the function (ensure-iterable-map-function return-type iterable))
               fn))
    )
  
  
  
  (validate-class iterable-class)
  
  
  
  ;; ------------------------------
  
  #+NIL
  (defun* map-iterable (fn iterable &optional (return-type t))
    (declare (type function fn)
             (type iterable iterable)
             (values t &optional))
    (let ((memb (etypecase iterable
                  (sequence-iterable
                   (sequence-iterable-members iterable))))
          ...
          )))
  