dto and find-update

10 files changed, 383 insertions, 383 deletions

diff --git a/srfi/225.sld b/srfi/225.sld
index 1d34430..94699e7 100644
--- a/srfi/225.sld
+++ b/srfi/225.sld
@@ -49,8 +49,8 @@
     dict-filter!
     dict-remove
     dict-remove!
-    dict-alter
-    dict-alter!
+    dict-find-update
+    dict-find-update!
 
     ;; whole dictionary
     dict-size
@@ -82,11 +82,11 @@
     dict-adjoin-accumulator
 
     ;; dictionary type descriptors
-    dtd?
-    make-dtd
-    dtd
-    make-alist-dtd
-    dtd-ref
+    dto?
+    make-dto
+    dto
+    make-alist-dto
+    dto-ref
 
     ;; exceptions
     dictionary-error
@@ -114,7 +114,7 @@
     dict-map-id
     dict-filter-id
     dict-remove-id
-    dict-alter-id
+    dict-find-update-id
     dict-size-id
     dict-count-id
     dict-any-id
@@ -139,9 +139,9 @@
     dict-set-accumulator-id
     dict-adjoin-accumulator-id
 
-    ;; basic DTDs
-    alist-eqv-dtd
-    alist-equal-dtd)
+    ;; basic DTOs
+    alist-eqv-dto
+    alist-equal-dto)
 
     ;; implementations
     (include "indexes.scm")
@@ -149,34 +149,34 @@
     (include "default-impl.scm")
     (include "alist-impl.scm")
 
-    ;; library-dependent DTD exports
+    ;; library-dependent DTO exports
     ;; and implementations
     ;;
-    ;;srfi-69-dtd
-    ;;hash-table-dtd
-    ;;srfi-126-dtd
-    ;;mapping-dtd
-    ;;hash-mapping-dtd
+    ;;srfi-69-dto
+    ;;hash-table-dto
+    ;;srfi-126-dto
+    ;;mapping-dto
+    ;;hash-mapping-dto
 
     (cond-expand
         ((library (srfi 69))
          (import (prefix (srfi 69) t69-))
          (include "srfi-69-impl.scm")
-         (export srfi-69-dtd))
+         (export srfi-69-dto))
         (else))
 
     (cond-expand
         ((library (srfi 125))
          (import (prefix (srfi 125) t125-))
          (include "srfi-125-impl.scm")
-         (export hash-table-dtd))
+         (export hash-table-dto))
         (else))
 
     (cond-expand
         ((library (srfi 126))
          (import (prefix (srfi 126) t126-))
          (include "srfi-126-impl.scm")
-         (export srfi-126-dtd))
+         (export srfi-126-dto))
         (else))
 
     (cond-expand
@@ -186,6 +186,6 @@
                  (srfi 146 hash))
          (include "srfi-146-impl.scm"
                   "srfi-146-hash-impl.scm")
-         (export mapping-dtd
-                 hash-mapping-dtd))
+         (export mapping-dto
+                 hash-mapping-dto))
         (else)))
diff --git a/srfi/alist-impl.scm b/srfi/alist-impl.scm
index e2b2a29..19d42b6 100644
--- a/srfi/alist-impl.scm
+++ b/srfi/alist-impl.scm
@@ -1,14 +1,14 @@
-(define (make-alist-dtd key=)
+(define (make-alist-dto key=)
 
-  (define (alist? dtd l)
+  (define (alist? dto l)
     (and (list? l)
          (or (null? l)
              (pair? (car l)))))
 
-  (define (alist-mutable? dtd alist)
+  (define (alist-mutable? dto alist)
     #f)
 
-  (define (alist-map dtd proc alist)
+  (define (alist-map dto proc alist)
     (map
      (lambda (e)
        (define key (car e))
@@ -16,19 +16,19 @@
        (cons key (proc key value)))
      alist))
 
-  (define (alist-filter dtd pred alist)
+  (define (alist-filter dto pred alist)
     (filter
      (lambda (e)
        (pred (car e) (cdr e)))
      alist))
 
-  (define (alist-delete dtd key alist)
+  (define (alist-delete dto key alist)
     (filter
      (lambda (entry)
        (not (key= (car entry) key)))
      alist))
 
-  (define (alist-alter dtd alist key failure success)
+  (define (alist-find-update dto alist key failure success)
     (define (handle-success pair)
       (define old-key (car pair))
       (define old-value (cdr pair))
@@ -43,10 +43,10 @@
           (let ((new-list
                  (alist-cons
                   new-key new-value
-                  (alist-delete dtd old-key alist))))
+                  (alist-delete dto old-key alist))))
             new-list))))
       (define (remove)
-        (alist-delete dtd old-key alist))
+        (alist-delete dto old-key alist))
       (success old-key old-value update remove))
 
     (define (handle-failure)
@@ -59,30 +59,30 @@
      ((assoc key alist key=) => handle-success)
      (else (handle-failure))))
 
-  (define (alist-size dtd alist)
+  (define (alist-size dto alist)
     (length alist))
 
-  (define (alist-foreach dtd proc alist)
+  (define (alist-foreach dto proc alist)
     (define (proc* e)
       (proc (car e) (cdr e)))
     (for-each proc* alist))
 
-  (define (alist->alist dtd alist)
+  (define (alist->alist dto alist)
     alist)
 
-  (define (alist-comparator dtd dictionary)
+  (define (alist-comparator dto dictionary)
     #f)
 
-  (make-dtd
+  (make-dto
    dictionary?-id alist?
    dict-mutable?-id alist-mutable?
    dict-map-id alist-map
    dict-filter-id alist-filter
-   dict-alter-id alist-alter
+   dict-find-update-id alist-find-update
    dict-size-id alist-size
    dict-for-each-id alist-foreach
    dict->alist-id alist->alist
    dict-comparator-id alist-comparator))
 
-(define alist-eqv-dtd (make-alist-dtd eqv?))
-(define alist-equal-dtd (make-alist-dtd equal?))
+(define alist-eqv-dto (make-alist-dto eqv?))
+(define alist-equal-dto (make-alist-dto equal?))
diff --git a/srfi/default-impl.scm b/srfi/default-impl.scm
index a0c9584..dea21ee 100644
--- a/srfi/default-impl.scm
+++ b/srfi/default-impl.scm
@@ -1,81 +1,81 @@
-(define default-dtd
+(define default-dto
   (let ()
 
-    ;; implementation of "default" dtd, used as a filler for undefined
-    ;; functions in other dtds
+    ;; implementation of "default" dto, used as a filler for undefined
+    ;; functions in other dtos
 
     ;; primitives
     (define (not-implemented name)
-      (lambda (dtd . args)
-        (raise (dictionary-error (string-append name " not implemented") dtd))))
+      (lambda (dto . args)
+        (raise (dictionary-error (string-append name " not implemented") dto))))
     (define default-dictionary? (not-implemented "dictionary?"))
     (define default-dict-mutable? (not-implemented "dict-mutable?"))
     (define default-dict-size (not-implemented "dict-size"))
-    (define default-dict-alter (not-implemented "dict-alter"))
+    (define default-dict-find-update (not-implemented "dict-find-update"))
 
-    (define (dict-alter* dtd dict key fail success)
-      (if (dict-mutable? dtd dict)
-          (dict-alter! dtd dict key fail success)
-          (dict-alter dtd dict key fail success)))
+    (define (dict-find-update* dto dict key fail success)
+      (if (dict-mutable? dto dict)
+          (dict-find-update! dto dict key fail success)
+          (dict-find-update dto dict key fail success)))
 
-    (define (dict-delete-all* dtd dict keys)
-      (if (dict-mutable? dtd dict)
-          (dict-delete-all! dtd dict keys)
-          (dict-delete-all dtd dict keys)))
+    (define (dict-delete-all* dto dict keys)
+      (if (dict-mutable? dto dict)
+          (dict-delete-all! dto dict keys)
+          (dict-delete-all dto dict keys)))
 
-    (define (dict-update* dtd dict key updater fail success)
-      (if (dict-mutable? dtd dict)
-          (dict-update! dtd dict key updater fail success)
-          (dict-update dtd dict key updater fail success)))
+    (define (dict-update* dto dict key updater fail success)
+      (if (dict-mutable? dto dict)
+          (dict-update! dto dict key updater fail success)
+          (dict-update dto dict key updater fail success)))
 
-    (define (dict-filter* dtd pred dictionary)
-      (if (dict-mutable? dtd dictionary)
-          (dict-filter! dtd pred dictionary)
-          (dict-filter dtd pred dictionary)))
+    (define (dict-filter* dto pred dictionary)
+      (if (dict-mutable? dto dictionary)
+          (dict-filter! dto pred dictionary)
+          (dict-filter dto pred dictionary)))
 
-    (define (dict-replace* dtd dict key val)
-      (if (dict-mutable? dtd dict)
-          (dict-replace! dtd dict key val)
-          (dict-replace dtd dict key val)))
+    (define (dict-replace* dto dict key val)
+      (if (dict-mutable? dto dict)
+          (dict-replace! dto dict key val)
+          (dict-replace dto dict key val)))
 
-    (define (default-dict-empty? dtd dictionary)
-      (= 0 (dict-size dtd dictionary)))
+    (define (default-dict-empty? dto dictionary)
+      (= 0 (dict-size dto dictionary)))
 
-    (define (default-dict=? dtd = dict1 dict2)
+    (define (default-dict=? dto = dict1 dict2)
       (define (check-entries* keys)
         (cond
           ((null? keys) #t)
           (else (let* ((key (car keys))
-                       (d1-value (dict-ref dtd dict1 key)))
-                  (dict-ref dtd dict2 key
+                       (d1-value (dict-ref dto dict1 key)))
+                  (dict-ref dto dict2 key
                             (lambda () #f)
                             (lambda (d2-value)
                               (if (= d1-value d2-value)
                                   (check-entries* (cdr keys))
                                   #f)))))))
-      (and (= (dict-size dtd dict1)
-              (dict-size dtd dict2))
-           (check-entries* (dict-keys dtd dict1))))
+      (and (= (dict-size dto dict1)
+              (dict-size dto dict2))
+           (check-entries* (dict-keys dto dict1))))
 
-    (define (default-dict-contains? dtd dictionary key)
-      (dict-ref dtd dictionary key
+    (define (default-dict-contains? dto dictionary key)
+      (dict-ref dto dictionary key
                 (lambda () #f)
                 (lambda (x) #t)))
 
-    (define (default-dict-ref dtd dictionary key failure success)
-      (dict-alter* dtd dictionary key
+    (define (default-dict-ref dto dictionary key failure success)
+      (dict-find-update* dto dictionary key
                      (lambda (insert ignore)
                        (failure))
                      (lambda (key value update remove)
                        (success value))))
 
-    (define (default-dict-ref/default dtd dictionary key default)
-      (dict-ref dtd dictionary key
+    (define (default-dict-ref/default dto dictionary key default)
+      (dict-ref dto dictionary key
                 (lambda () default)
                 (lambda (x) x)))
 
     ;; private
-    (define (default-dict-set* dtd dictionary use-old? objs)
+    (define (default-dict-set* dto dictionary use-old? objs)
       (let loop ((objs objs)
                  (dictionary dictionary))
         (cond
@@ -85,7 +85,7 @@
           (error "mismatch of key / values argument list" objs))
          (else (let* ((key (car objs))
                       (value (cadr objs))
-                      (new-d (dict-alter* dtd dictionary key
+                      (new-d (dict-find-update* dto dictionary key
                                          (lambda (insert ignore)
                                            (insert value))
                                          (lambda (key old-value update delete)
@@ -93,22 +93,22 @@
                  (loop (cddr objs)
                        new-d))))))
 
-    (define (default-dict-set dtd dictionary . objs)
-      (default-dict-set* dtd dictionary #f objs))
+    (define (default-dict-set dto dictionary . objs)
+      (default-dict-set* dto dictionary #f objs))
 
-    (define (default-dict-adjoin dtd dictionary . objs)
-      (default-dict-set* dtd dictionary #t objs))
+    (define (default-dict-adjoin dto dictionary . objs)
+      (default-dict-set* dto dictionary #t objs))
 
-    (define (default-dict-delete dtd dictionary . keys)
-      (dict-delete-all* dtd dictionary keys))
+    (define (default-dict-delete dto dictionary . keys)
+      (dict-delete-all* dto dictionary keys))
 
-    (define (default-dict-delete-all dtd dictionary keylist)
+    (define (default-dict-delete-all dto dictionary keylist)
       (let loop ((keylist keylist)
                  (d dictionary))
         (cond
           ((null? keylist) d)
           (else (let* ((key (car keylist))
-                       (new-d (dict-alter* dtd d key
+                       (new-d (dict-find-update* dto d key
                                           (lambda (_ ignore)
                                             (ignore))
                                           (lambda (key old-value _ delete)
@@ -116,75 +116,75 @@
                   (loop (cdr keylist)
                         new-d))))))
 
-    (define (default-dict-replace dtd dictionary key value)
-      (dict-alter* dtd dictionary key
+    (define (default-dict-replace dto dictionary key value)
+      (dict-find-update* dto dictionary key
                   (lambda (_ ignore)
                     (ignore))
                   (lambda (key old-value update _)
                     (update key value))))
 
-    (define (default-dict-intern dtd dictionary key failure)
-      (dict-alter* dtd dictionary key
+    (define (default-dict-intern dto dictionary key failure)
+      (dict-find-update* dto dictionary key
                   (lambda (insert _)
                     (let ((value (failure)))
                      (values (insert value) value)))
                   (lambda (key value update _)
                     (values dictionary value))))
 
-    (define (default-dict-update dtd dictionary key updater failure success)
-      (dict-alter* dtd dictionary key
+    (define (default-dict-update dto dictionary key updater failure success)
+      (dict-find-update* dto dictionary key
                   (lambda (insert ignore)
                     (insert (updater (failure))))
                   (lambda (key value update _)
                     (update key (updater (success value))))))
 
-    (define (default-dict-update/default dtd dictionary key updater default)
-      (dict-update* dtd dictionary key updater
+    (define (default-dict-update/default dto dictionary key updater default)
+      (dict-update* dto dictionary key updater
                     (lambda () default)
                     (lambda (x) x)))
 
-    (define (default-dict-pop dtd dictionary)
+    (define (default-dict-pop dto dictionary)
       (define (do-pop)
         (call/cc
          (lambda (cont)
-           (dict-for-each dtd
+           (dict-for-each dto
                           (lambda (key value)
                             (define new-dict
-                              (dict-delete-all* dtd dictionary (list key)))
+                              (dict-delete-all* dto dictionary (list key)))
                             (cont new-dict key value))
                           dictionary))))
-      (define empty? (dict-empty? dtd dictionary))
+      (define empty? (dict-empty? dto dictionary))
       (if empty?
           (error "popped empty dictionary")
           (do-pop)))
 
-    (define (default-dict-map dtd mapper dictionary)
-      (define keys (dict-keys dtd dictionary))
+    (define (default-dict-map dto mapper dictionary)
+      (define keys (dict-keys dto dictionary))
       (let loop ((keys keys)
                  (dict dictionary))
         (if (null? keys)
             dict
             (let* ((key (car keys))
-                   (val (mapper key (dict-ref dtd dict key))))
+                   (val (mapper key (dict-ref dto dict key))))
               (loop (cdr keys)
-                    (dict-replace* dtd dict key val))))))
+                    (dict-replace* dto dict key val))))))
 
-    (define (default-dict-filter dtd pred dictionary)
-      (define keys (dict-keys dtd dictionary))
+    (define (default-dict-filter dto pred dictionary)
+      (define keys (dict-keys dto dictionary))
       (define keys-to-delete
         (filter
          (lambda (key)
-           (not (pred key (dict-ref dtd dictionary key))))
+           (not (pred key (dict-ref dto dictionary key))))
          keys))
-      (dict-delete-all* dtd dictionary keys-to-delete))
+      (dict-delete-all* dto dictionary keys-to-delete))
 
-    (define (default-dict-remove dtd pred dictionary)
-      (dict-filter* dtd (lambda (key value)
+    (define (default-dict-remove dto pred dictionary)
+      (dict-filter* dto (lambda (key value)
                           (not (pred key value)))
                     dictionary))
 
-    (define (default-dict-count dtd pred dictionary)
-      (dict-fold dtd
+    (define (default-dict-count dto pred dictionary)
+      (dict-fold dto
                  (lambda (key value acc)
                    (if (pred key value)
                        (+ 1 acc)
@@ -192,10 +192,10 @@
                  0
                  dictionary))
 
-    (define (default-dict-any dtd pred dictionary)
+    (define (default-dict-any dto pred dictionary)
       (call/cc
        (lambda (cont)
-         (dict-for-each dtd
+         (dict-for-each dto
                         (lambda (key value)
                           (define ret (pred key value))
                           (when ret
@@ -203,11 +203,11 @@
                         dictionary)
          #f)))
 
-    (define (default-dict-every dtd pred dictionary)
+    (define (default-dict-every dto pred dictionary)
       (define last #t)
       (call/cc
        (lambda (cont)
-         (dict-for-each dtd
+         (dict-for-each dto
                         (lambda (key value)
                           (define ret (pred key value))
                           (when (not ret)
@@ -216,25 +216,25 @@
                         dictionary)
          last)))
 
-    (define (default-dict-keys dtd dictionary)
+    (define (default-dict-keys dto dictionary)
       (reverse
-       (dict-fold dtd
+       (dict-fold dto
                   (lambda (key value acc)
                     (cons key acc))
                   '()
                   dictionary)))
 
-    (define (default-dict-values dtd dictionary)
+    (define (default-dict-values dto dictionary)
       (reverse
-       (dict-fold dtd
+       (dict-fold dto
                   (lambda (key value acc)
                     (cons value acc))
                   '()
                   dictionary)))
 
-    (define (default-dict-entries dtd dictionary)
+    (define (default-dict-entries dto dictionary)
       (define pair
-        (dict-fold dtd
+        (dict-fold dto
                    (lambda (key value acc)
                      (cons (cons key (car acc))
                            (cons value (cdr acc))))
@@ -243,25 +243,25 @@
       (values (reverse (car pair))
               (reverse (cdr pair))))
 
-    (define (default-dict-fold dtd proc knil dictionary)
+    (define (default-dict-fold dto proc knil dictionary)
       (define acc knil)
-      (dict-for-each dtd
+      (dict-for-each dto
                      (lambda (key value)
                        (set! acc (proc key value acc)))
                      dictionary)
       acc)
 
-    (define (default-dict-map->list dtd proc dictionary)
+    (define (default-dict-map->list dto proc dictionary)
       (define reverse-lst
-        (dict-fold dtd
+        (dict-fold dto
                    (lambda (key value lst)
                      (cons (proc key value) lst))
                    '()
                    dictionary))
       (reverse reverse-lst))
 
-    (define (default-dict->alist dtd dictionary)
-      (dict-map->list dtd
+    (define (default-dict->alist dto dictionary)
+      (dict-map->list dto
                       cons
                       dictionary))
 
@@ -269,66 +269,66 @@
 
     (define default-dict-for-each (not-implemented "dict-for-each"))
 
-    (define (default-dict-for-each/filtered dtd pred proc dict)
-      (dict-for-each dtd
+    (define (default-dict-for-each/filtered dto pred proc dict)
+      (dict-for-each dto
                      (lambda (key value)
                        (when (pred key)
                          (proc key value)))
                      dict))
 
-    (define (default-dict-for-each< dtd proc dict key)
-      (define cmp (dict-comparator dtd dict))
+    (define (default-dict-for-each< dto proc dict key)
+      (define cmp (dict-comparator dto dict))
       (define (pred k)
         (<? cmp k key))
-      (default-dict-for-each/filtered dtd pred proc dict))
+      (default-dict-for-each/filtered dto pred proc dict))
 
-    (define (default-dict-for-each<= dtd proc dict key)
-      (define cmp (dict-comparator dtd dict))
+    (define (default-dict-for-each<= dto proc dict key)
+      (define cmp (dict-comparator dto dict))
       (define (pred k)
         (<=? cmp k key))
-      (default-dict-for-each/filtered dtd pred proc dict))
+      (default-dict-for-each/filtered dto pred proc dict))
 
-    (define (default-dict-for-each> dtd proc dict key)
-      (define cmp (dict-comparator dtd dict))
+    (define (default-dict-for-each> dto proc dict key)
+      (define cmp (dict-comparator dto dict))
       (define (pred k)
         (>? cmp k key))
-      (default-dict-for-each/filtered dtd pred proc dict))
+      (default-dict-for-each/filtered dto pred proc dict))
 
-    (define (default-dict-for-each>= dtd proc dict key)
-      (define cmp (dict-comparator dtd dict))
+    (define (default-dict-for-each>= dto proc dict key)
+      (define cmp (dict-comparator dto dict))
       (define (pred k)
         (>=? cmp k key))
-      (default-dict-for-each/filtered dtd pred proc dict))
+      (default-dict-for-each/filtered dto pred proc dict))
 
-    (define (default-dict-for-each-in-open-interval dtd proc dict key1 key2)
-      (define cmp (dict-comparator dtd dict))
+    (define (default-dict-for-each-in-open-interval dto proc dict key1 key2)
+      (define cmp (dict-comparator dto dict))
       (define (pred k)
         (<? cmp key1 k key2))
-      (default-dict-for-each/filtered dtd pred proc dict))
+      (default-dict-for-each/filtered dto pred proc dict))
 
-    (define (default-dict-for-each-in-closed-interval dtd proc dict key1 key2)
-      (define cmp (dict-comparator dtd dict))
+    (define (default-dict-for-each-in-closed-interval dto proc dict key1 key2)
+      (define cmp (dict-comparator dto dict))
       (define (pred k)
         (<=? cmp key1 k key2))
-      (default-dict-for-each/filtered dtd pred proc dict))
+      (default-dict-for-each/filtered dto pred proc dict))
 
-    (define (default-dict-for-each-in-open-closed-interval dtd proc dict key1 key2)
-      (define cmp (dict-comparator dtd dict))
+    (define (default-dict-for-each-in-open-closed-interval dto proc dict key1 key2)
+      (define cmp (dict-comparator dto dict))
       (define (pred k)
         (and (<? cmp key1 k)
              (<=? cmp k key2)))
-      (default-dict-for-each/filtered dtd pred proc dict))
+      (default-dict-for-each/filtered dto pred proc dict))
 
-    (define (default-dict-for-each-in-closed-open-interval dtd proc dict key1 key2)
-      (define cmp (dict-comparator dtd dict))
+    (define (default-dict-for-each-in-closed-open-interval dto proc dict key1 key2)
+      (define cmp (dict-comparator dto dict))
       (define (pred k)
         (and (<=? cmp key1 k)
              (<? cmp k key2)))
-      (default-dict-for-each/filtered dtd pred proc dict))
+      (default-dict-for-each/filtered dto pred proc dict))
 
-    (define (default-make-dict-generator dtd dict)
+    (define (default-make-dict-generator dto dict)
       (define-values (keys vals)
-                     (dict-entries dtd dict))
+                     (dict-entries dto dict))
       (lambda ()
         (if (null? keys)
             (eof-object)
@@ -338,27 +338,27 @@
               (set! vals (cdr vals))
               (cons key value)))))
 
-    (define (default-dict-accumulator dtd dict acc-proc)
+    (define (default-dict-accumulator dto dict acc-proc)
       (lambda (arg)
         (if (eof-object? arg)
             dict
-            (set! dict (acc-proc dtd dict (car arg) (cdr arg))))))
+            (set! dict (acc-proc dto dict (car arg) (cdr arg))))))
 
-    (define (default-dict-set-accumulator dtd dict)
-      (if (dict-mutable? dtd dict)
-          (default-dict-accumulator dtd dict dict-set!)
-          (default-dict-accumulator dtd dict dict-set)))
+    (define (default-dict-set-accumulator dto dict)
+      (if (dict-mutable? dto dict)
+          (default-dict-accumulator dto dict dict-set!)
+          (default-dict-accumulator dto dict dict-set)))
 
-    (define (default-dict-adjoin-accumulator dtd dict)
-      (if (dict-mutable? dtd dict)
-          (default-dict-accumulator dtd dict dict-adjoin!)
-          (default-dict-accumulator dtd dict dict-adjoin)))
+    (define (default-dict-adjoin-accumulator dto dict)
+      (if (dict-mutable? dto dict)
+          (default-dict-accumulator dto dict dict-adjoin!)
+          (default-dict-accumulator dto dict dict-adjoin)))
 
     (let ()
-      (define null-dtd (make-dtd-private (make-vector dict-procedures-count #f)))
-      (define default-dtd
-        (make-modified-dtd
-         null-dtd
+      (define null-dto (make-dto-private (make-vector dict-procedures-count #f)))
+      (define default-dto
+        (make-modified-dto
+         null-dto
          dictionary?-id default-dictionary?
          dict-empty?-id default-dict-empty?
          dict-contains?-id default-dict-contains?
@@ -378,7 +378,7 @@
          dict-map-id default-dict-map
          dict-filter-id default-dict-filter
          dict-remove-id default-dict-remove
-         dict-alter-id default-dict-alter
+         dict-find-update-id default-dict-find-update
          dict-size-id default-dict-size
          dict-count-id default-dict-count
          dict-any-id default-dict-any
@@ -411,7 +411,7 @@
        (lambda (proc index)
          (unless (and proc (procedure? proc))
            (error "Missing or wrong default procedure definition" proc index)))
-       (procvec default-dtd)
+       (procvec default-dto)
        (list->vector (iota dict-procedures-count)))
 
-      default-dtd)))
+      default-dto)))
diff --git a/srfi/externals.scm b/srfi/externals.scm
index 519bccf..ce24b19 100644
--- a/srfi/externals.scm
+++ b/srfi/externals.scm
@@ -1,62 +1,62 @@
 ;; procedure definitions that don't rely on concrete implementations
 
-(define-record-type <dtd>
-  (make-dtd-private procvec)
-  dtd?
+(define-record-type <dto>
+  (make-dto-private procvec)
+  dto?
   (procvec procvec))
 
-(define-record-type <dtd-err>
+(define-record-type <dto-err>
   (make-dictionary-error message irritants)
   dictionary-error?
   (message dictionary-message)
   (irritants dictionary-irritants))
 
-;; shorthand access to dtd procedure by index
-(define-syntax dtd-ref-stx
+;; shorthand access to dto procedure by index
+(define-syntax dto-ref-stx
   (syntax-rules ()
-    ((_ dtd index)
+    ((_ dto index)
      (begin
-       (vector-ref (procvec dtd) index)))))
+       (vector-ref (procvec dto) index)))))
 
 ;; shorthand to define proc with using proc index
 (define-syntax define/dict-proc
   (syntax-rules ()
     ((_ proc index)
-     (define (proc dtd . args)
-       (assume (dtd? dtd))
-       (apply (dtd-ref-stx dtd index) dtd args)))))
+     (define (proc dto . args)
+       (assume (dto? dto))
+       (apply (dto-ref-stx dto index) dto args)))))
 
 ;; define mutable and immutable versions of a procedure (such as dict-set! and dict-set)
 ;; with appropriate assertion for dict-mutable? value
-;; when dtd is first arg, and dict is second arg
+;; when dto is first arg, and dict is second arg
 (define-syntax define/dict-proc-pair
   (syntax-rules ()
     ((_ proc-immutable proc-mutable index)
      (begin
-       (define (proc-mutable dtd dict . args)
-         (assume (dtd? dtd))
-         (assume ((dtd-ref-stx dtd dict-mutable?-id) dtd dict) index)
-         (apply (dtd-ref-stx dtd index) dtd dict args))
-       (define (proc-immutable dtd dict . args)
-         (assume (dtd? dtd))
-         (assume (not ((dtd-ref-stx dtd dict-mutable?-id) dtd dict)) index)
-         (apply (dtd-ref-stx dtd index) dtd dict args))))))
+       (define (proc-mutable dto dict . args)
+         (assume (dto? dto))
+         (assume ((dto-ref-stx dto dict-mutable?-id) dto dict) index)
+         (apply (dto-ref-stx dto index) dto dict args))
+       (define (proc-immutable dto dict . args)
+         (assume (dto? dto))
+         (assume (not ((dto-ref-stx dto dict-mutable?-id) dto dict)) index)
+         (apply (dto-ref-stx dto index) dto dict args))))))
 
 ;; define mutable and immutable versions of a procedure (such as dict-set! and dict-set)
 ;; with appropriate assertion for dict-mutable? value
-;; when dtd is first arg, and dict is third arg (ie filter, map shape signature)
+;; when dto is first arg, and dict is third arg (ie filter, map shape signature)
 (define-syntax define/dict-proc-pair*
   (syntax-rules ()
     ((_ proc-immutable proc-mutable index)
      (begin
-       (define (proc-mutable dtd proc dict)
-         (assume (dtd? dtd))
-         (assume ((dtd-ref-stx dtd dict-mutable?-id) dtd dict) index)
-         ((dtd-ref-stx dtd index) dtd proc dict))
-       (define (proc-immutable dtd proc dict)
-         (assume (dtd? dtd))
-         (assume (not ((dtd-ref-stx dtd dict-mutable?-id) dtd dict)) index)
-         ((dtd-ref-stx dtd index) dtd proc dict))))))
+       (define (proc-mutable dto proc dict)
+         (assume (dto? dto))
+         (assume ((dto-ref-stx dto dict-mutable?-id) dto dict) index)
+         ((dto-ref-stx dto index) dto proc dict))
+       (define (proc-immutable dto proc dict)
+         (assume (dto? dto))
+         (assume (not ((dto-ref-stx dto dict-mutable?-id) dto dict)) index)
+         ((dto-ref-stx dto index) dto proc dict))))))
 
 (define/dict-proc dictionary? dictionary?-id)
 (define/dict-proc dict-empty? dict-empty?-id)
@@ -66,17 +66,17 @@
 
 (define dict-ref
   (case-lambda
-    ((dtd dict key)
-     (dict-ref dtd dict key
+    ((dto dict key)
+     (dict-ref dto dict key
                (lambda () (error "Key not found in dictionary" dict key))
                values))
 
-    ((dtd dict key failure)
-     (dict-ref dtd dict key failure values))
+    ((dto dict key failure)
+     (dict-ref dto dict key failure values))
 
-    ((dtd dict key failure success)
-     (assume (dtd? dtd))
-     ((dtd-ref-stx dtd dict-ref-id) dtd dict key failure success))))
+    ((dto dict key failure success)
+     (assume (dto? dto))
+     ((dto-ref-stx dto dict-ref-id) dto dict key failure success))))
 
 (define/dict-proc dict-ref/default dict-ref/default-id)
 (define/dict-proc-pair dict-set dict-set! dict-set-id)
@@ -88,40 +88,40 @@
 
 (define dict-update
   (case-lambda
-    ((dtd dict key updater)
-     (dict-update dtd dict key updater
+    ((dto dict key updater)
+     (dict-update dto dict key updater
                   (lambda () (error "Key not found in dictionary" dict key))
                   values))
 
-    ((dtd dict key updater failure)
-     (dict-update dtd dict key  updater failure values))
+    ((dto dict key updater failure)
+     (dict-update dto dict key  updater failure values))
 
-    ((dtd dict key updater failure success)
-     (assume (dtd? dtd))
-     (assume (not ((dtd-ref-stx dtd dict-mutable?-id) dtd dict)))
-     ((dtd-ref-stx dtd dict-update-id) dtd dict key updater failure success))))
+    ((dto dict key updater failure success)
+     (assume (dto? dto))
+     (assume (not ((dto-ref-stx dto dict-mutable?-id) dto dict)))
+     ((dto-ref-stx dto dict-update-id) dto dict key updater failure success))))
 
 (define dict-update!
   (case-lambda
-    ((dtd dict key updater)
-     (dict-update dtd dict key updater
+    ((dto dict key updater)
+     (dict-update dto dict key updater
                   (lambda () (error "Key not found in dictionary" dict key))
                   values))
 
-    ((dtd dict key updater failure)
-     (dict-update dtd dict key  updater failure values))
+    ((dto dict key updater failure)
+     (dict-update dto dict key  updater failure values))
 
-    ((dtd dict key updater failure success)
-     (assume (dtd? dtd))
-     (assume ((dtd-ref-stx dtd dict-mutable?-id) dtd dict))
-     ((dtd-ref-stx dtd dict-update-id) dtd dict key updater failure success))))
+    ((dto dict key updater failure success)
+     (assume (dto? dto))
+     (assume ((dto-ref-stx dto dict-mutable?-id) dto dict))
+     ((dto-ref-stx dto dict-update-id) dto dict key updater failure success))))
 
 (define/dict-proc-pair dict-update/default dict-update/default! dict-update/default-id)
 (define/dict-proc-pair dict-pop dict-pop! dict-pop-id)
 (define/dict-proc-pair* dict-map dict-map! dict-map-id)
 (define/dict-proc-pair* dict-filter dict-filter! dict-filter-id)
 (define/dict-proc-pair* dict-remove dict-remove! dict-remove-id)
-(define/dict-proc-pair dict-alter dict-alter! dict-alter-id)
+(define/dict-proc-pair dict-find-update dict-find-update! dict-find-update-id)
 (define/dict-proc dict-size dict-size-id)
 (define/dict-proc dict-count dict-count-id)
 (define/dict-proc dict-any dict-any-id)
@@ -146,11 +146,11 @@
 (define/dict-proc dict-set-accumulator dict-set-accumulator-id)
 (define/dict-proc dict-adjoin-accumulator dict-adjoin-accumulator-id)
 
-(define (dtd-ref dtd procindex)
-  (dtd-ref-stx dtd procindex))
+(define (dto-ref dto procindex)
+  (dto-ref-stx dto procindex))
 
-(define (make-modified-dtd dtd . lst)
-  (define vec (vector-copy (procvec dtd)))
+(define (make-modified-dto dto . lst)
+  (define vec (vector-copy (procvec dto)))
   (do ((lst lst (cddr lst)))
       ((null? lst))
     (when (null? (cdr lst))
@@ -160,22 +160,22 @@
       (unless (procedure? proc)
         (error "Not a procedure" proc))
       (vector-set! vec proc-id proc)))
-  (make-dtd-private vec))
+  (make-dto-private vec))
 
-(define (make-dtd . lst)
-  (apply make-modified-dtd default-dtd lst))
+(define (make-dto . lst)
+  (apply make-modified-dto default-dto lst))
 
-(define-syntax dtd-helper
+(define-syntax dto-helper
   (syntax-rules ()
     ((_ (arg ...) (index proc) rest ...)
-     (dtd-helper (arg ... index proc) rest ...))
+     (dto-helper (arg ... index proc) rest ...))
     ((_ (arg ...))
-     (make-dtd arg ...))))
+     (make-dto arg ...))))
 
-(define-syntax dtd
+(define-syntax dto
   (syntax-rules ()
     ((_ (index proc) ...)
-     (dtd-helper () (index proc) ...))))
+     (dto-helper () (index proc) ...))))
 
 (define (dictionary-error message . irritants)
   (make-dictionary-error message irritants))
diff --git a/srfi/indexes.scm b/srfi/indexes.scm
index a353de8..2121558 100644
--- a/srfi/indexes.scm
+++ b/srfi/indexes.scm
@@ -24,7 +24,7 @@
 (define dict-map-id (proc-id-inc))
 (define dict-filter-id (proc-id-inc))
 (define dict-remove-id (proc-id-inc))
-(define dict-alter-id (proc-id-inc))
+(define dict-find-update-id (proc-id-inc))
 (define dict-size-id (proc-id-inc))
 (define dict-count-id (proc-id-inc))
 (define dict-any-id (proc-id-inc))
diff --git a/srfi/srfi-125-impl.scm b/srfi/srfi-125-impl.scm
index 9ac64d7..1d5cf8e 100644
--- a/srfi/srfi-125-impl.scm
+++ b/srfi/srfi-125-impl.scm
@@ -1,4 +1,4 @@
-(define hash-table-dtd
+(define hash-table-dto
   (let ()
 
    (define-syntax guard-immutable
@@ -13,30 +13,30 @@
              (let ((table (t125-hash-table-copy table #f)))
               final-expr))))))
 
-   (define (t125-hash-table-mutable?* dtd table)
+   (define (t125-hash-table-mutable?* dto table)
      (t125-hash-table-mutable? table))
 
-    (define (t125-hash-table-set* dtd table . obj)
+    (define (t125-hash-table-set* dto table . obj)
       (guard-immutable table
         (apply t125-hash-table-set! (cons table obj))
         table))
 
-    (define (t125-hash-table-update* dtd table key updater fail success)
+    (define (t125-hash-table-update* dto table key updater fail success)
       (guard-immutable table
         (t125-hash-table-update! table key updater fail success)
         table))
 
-    (define (t125-hash-table-update/default* dtd table key proc default)
+    (define (t125-hash-table-update/default* dto table key proc default)
       (guard-immutable table
         (t125-hash-table-update!/default table key proc default)
         table))
 
-    (define (t125-hash-table-intern* dtd table key failure)
+    (define (t125-hash-table-intern* dto table key failure)
       (guard-immutable table
         (define val (t125-hash-table-intern! table key failure))
         (values table val)))
 
-    (define (t125-hash-table-pop* dtd table)
+    (define (t125-hash-table-pop* dto table)
       (if (t125-hash-table-empty? table)
           (error "popped empty dictionary")
           (guard-immutable table
@@ -45,7 +45,7 @@
               (t125-hash-table-pop! table))
             (values table key value))))
 
-    (define (t125-hash-table-delete-all* dtd table keys)
+    (define (t125-hash-table-delete-all* dto table keys)
       (guard-immutable table
         (for-each
           (lambda (key)
@@ -53,12 +53,12 @@
           keys)
         table))
 
-    (define (t125-hash-table-map* dtd proc table)
+    (define (t125-hash-table-map* dto proc table)
       (guard-immutable table
         (t125-hash-table-map! proc table)
         table))
 
-    (define (t125-hash-table-filter* dtd proc table)
+    (define (t125-hash-table-filter* dto proc table)
       (guard-immutable table
         (t125-hash-table-prune!
           (lambda (key value)
@@ -66,12 +66,12 @@
           table)
         table))
 
-    (define (t125-hash-table-remove* dtd proc table)
+    (define (t125-hash-table-remove* dto proc table)
       (guard-immutable table
         (t125-hash-table-prune! proc table)
         table))
 
-    (define (t125-hash-table-alter* dtd table key fail success)
+    (define (t125-hash-table-find-update* dto table key fail success)
       (define (handle-success value)
         (define (update new-key new-value)
           (guard-immutable table
@@ -96,55 +96,55 @@
       (define default (cons #f #f))
       (t125-hash-table-ref table key handle-fail handle-success))
 
-    (define (t125-hash-table-comparator* dtd table)
+    (define (t125-hash-table-comparator* dto table)
       (make-comparator (lambda args #t)
                        (t125-hash-table-equivalence-function table)
                        #f
                        (t125-hash-table-hash-function table)))
 
-    (define (t125-hash-table-copy* dtd table)
+    (define (t125-hash-table-copy* dto table)
       (t125-hash-table-copy table #t))
 
-    (define (t125-hash-table-size* dtd table)
+    (define (t125-hash-table-size* dto table)
       (t125-hash-table-size table))
 
-    (define (t125-hash-table-for-each* dtd proc table)
+    (define (t125-hash-table-for-each* dto proc table)
       (t125-hash-table-for-each proc table))
 
-    (define (t125-hash-table-keys* dtd table)
+    (define (t125-hash-table-keys* dto table)
       (t125-hash-table-keys table))
 
-    (define (t125-hash-table-values* dtd table)
+    (define (t125-hash-table-values* dto table)
       (t125-hash-table-values table))
 
-    (define (t125-hash-table-entries* dtd table)
+    (define (t125-hash-table-entries* dto table)
       (t125-hash-table-entries table))
 
-    (define (t125-hash-table-fold* dtd proc knil table)
+    (define (t125-hash-table-fold* dto proc knil table)
       (t125-hash-table-fold proc knil table))
 
-    (define (t125-hash-table-map->list* dtd proc table)
+    (define (t125-hash-table-map->list* dto proc table)
       (t125-hash-table-map->list proc table))
 
-    (define (t125-hash-table->alist* dtd table)
+    (define (t125-hash-table->alist* dto table)
       (t125-hash-table->alist table))
 
-    (define (t125-hash-table?* dtd table)
+    (define (t125-hash-table?* dto table)
       (t125-hash-table? table))
 
-    (define (t125-hash-table-empty?* dtd table)
+    (define (t125-hash-table-empty?* dto table)
       (t125-hash-table-empty? table))
 
-    (define (t125-hash-table-contains?* dtd table key)
+    (define (t125-hash-table-contains?* dto table key)
       (t125-hash-table-contains? table key))
 
-    (define (t125-hash-table-ref* dtd table key failure success)
+    (define (t125-hash-table-ref* dto table key failure success)
       (t125-hash-table-ref table key failure success))
 
-    (define (t125-hash-table-ref/default* dtd table key default)
+    (define (t125-hash-table-ref/default* dto table key default)
       (t125-hash-table-ref/default table key default))
 
-    (make-dtd
+    (make-dto
      dictionary?-id t125-hash-table?*
      dict-mutable?-id t125-hash-table-mutable?*
      dict-empty?-id t125-hash-table-empty?*
@@ -160,7 +160,7 @@
      dict-map-id t125-hash-table-map*
      dict-filter-id t125-hash-table-filter*
      dict-remove-id t125-hash-table-remove*
-     dict-alter-id t125-hash-table-alter*
+     dict-find-update-id t125-hash-table-find-update*
      dict-size-id t125-hash-table-size*
      dict-for-each-id t125-hash-table-for-each*
      dict-keys-id t125-hash-table-keys*
diff --git a/srfi/srfi-126-impl.scm b/srfi/srfi-126-impl.scm
index bb55941..e1f62f1 100644
--- a/srfi/srfi-126-impl.scm
+++ b/srfi/srfi-126-impl.scm
@@ -1,4 +1,4 @@
-(define srfi-126-dtd
+(define srfi-126-dto
   (let ()
 
    (define-syntax guard-immutable
@@ -13,20 +13,20 @@
              (let ((table (t126-hashtable-copy table #f)))
               final-expr))))))
 
-    (define (prep-dtd-arg proc)
-      (lambda (dtd . args)
+    (define (prep-dto-arg proc)
+      (lambda (dto . args)
         (apply proc args)))
 
-    (define (t126-hashtable-ref* dtd table key fail success)
+    (define (t126-hashtable-ref* dto table key fail success)
       (define-values (value found?) (t126-hashtable-lookup table key))
       (if found?
           (success value)
           (fail)))
 
-    (define (t126-hashtable-ref/default* dtd table key default)
+    (define (t126-hashtable-ref/default* dto table key default)
       (t126-hashtable-ref table key default))
 
-    (define (t126-hashtable-set* dtd table . obj)
+    (define (t126-hashtable-set* dto table . obj)
       (guard-immutable table
         (let loop ((obj obj))
          (if (null? obj)
@@ -36,7 +36,7 @@
                (loop (cddr obj)))))
         table))
 
-    (define (t126-hashtable-delete-all* dtd table keys)
+    (define (t126-hashtable-delete-all* dto table keys)
       (guard-immutable table
         (for-each
           (lambda (key)
@@ -44,17 +44,17 @@
           keys)
         table))
 
-    (define (t126-hashtable-intern* dtd table key default)
+    (define (t126-hashtable-intern* dto table key default)
       (guard-immutable table
         (define val (t126-hashtable-intern! table key default))
         (values table val)))
 
-    (define (t126-hashtable-update/default* dtd table key updater default)
+    (define (t126-hashtable-update/default* dto table key updater default)
       (guard-immutable table
         (t126-hashtable-update! table key updater default)
         table))
 
-    (define (t126-hashtable-pop* dtd table)
+    (define (t126-hashtable-pop* dto table)
       (if (t126-hashtable-empty? table)
           (error "popped empty dictionary")
           (guard-immutable table
@@ -63,24 +63,24 @@
               (t126-hashtable-pop! table))
             (values table key value))))
 
-    (define (t126-hashtable-update-all* dtd proc table)
+    (define (t126-hashtable-update-all* dto proc table)
       (guard-immutable table
         (t126-hashtable-update-all! table proc)
         table))
 
-    (define (t126-hashtable-filter* dtd proc table)
+    (define (t126-hashtable-filter* dto proc table)
       (guard-immutable table
         (t126-hashtable-prune! table
                                (lambda (key value)
                                  (not (proc key value))))
         table))
 
-    (define (t126-hashtable-remove* dtd proc table)
+    (define (t126-hashtable-remove* dto proc table)
       (guard-immutable table
         (t126-hashtable-prune! table proc)
         table))
 
-    (define (t126-hashtable-alter* dtd table key fail success)
+    (define (t126-hashtable-find-update* dto table key fail success)
       (define (handle-success value)
         (define (update new-key new-value)
           (guard-immutable table
@@ -108,20 +108,20 @@
           (handle-fail)
           (handle-success found)))
 
-    (define (t126-hashtable-for-each* dtd proc table)
+    (define (t126-hashtable-for-each* dto proc table)
       (t126-hashtable-walk table proc)
       table)
 
-    (define (t126-hashtable-map->lset* dtd proc table)
+    (define (t126-hashtable-map->lset* dto proc table)
       (t126-hashtable-map->lset table proc))
 
-    (define (t126-hashtable-keys* dtd table)
+    (define (t126-hashtable-keys* dto table)
       (vector->list (t126-hashtable-keys table)))
 
-    (define (t126-hashtable-values* dtd table)
+    (define (t126-hashtable-values* dto table)
       (vector->list (t126-hashtable-values table)))
 
-    (define (t126-hashtable-entries* dtd table)
+    (define (t126-hashtable-entries* dto table)
       (call-with-values
           (lambda () (t126-hashtable-entries table))
         (lambda (keys vals)
@@ -129,14 +129,14 @@
            (vector->list keys)
            (vector->list vals)))))
 
-    (define (t126-hashtable-comparator* dtd table)
+    (define (t126-hashtable-comparator* dto table)
       #f)
 
-    (make-dtd
-     dictionary?-id (prep-dtd-arg t126-hashtable?)
-     dict-mutable?-id (prep-dtd-arg t126-hashtable-mutable?)
-     dict-empty?-id (prep-dtd-arg t126-hashtable-empty?)
-     dict-contains?-id (prep-dtd-arg t126-hashtable-contains?)
+    (make-dto
+     dictionary?-id (prep-dto-arg t126-hashtable?)
+     dict-mutable?-id (prep-dto-arg t126-hashtable-mutable?)
+     dict-empty?-id (prep-dto-arg t126-hashtable-empty?)
+     dict-contains?-id (prep-dto-arg t126-hashtable-contains?)
      dict-ref-id t126-hashtable-ref*
      dict-ref/default-id t126-hashtable-ref/default*
      dict-set-id t126-hashtable-set*
@@ -147,8 +147,8 @@
      dict-map-id t126-hashtable-update-all*
      dict-filter-id t126-hashtable-filter*
      dict-remove-id t126-hashtable-remove*
-     dict-alter-id t126-hashtable-alter*
-     dict-size-id (prep-dtd-arg t126-hashtable-size)
+     dict-find-update-id t126-hashtable-find-update*
+     dict-size-id (prep-dto-arg t126-hashtable-size)
      dict-for-each-id t126-hashtable-for-each*
      dict-keys-id t126-hashtable-keys*
      dict-values-id t126-hashtable-values*
diff --git a/srfi/srfi-146-hash-impl.scm b/srfi/srfi-146-hash-impl.scm
index fb8497e..822fe7f 100644
--- a/srfi/srfi-146-hash-impl.scm
+++ b/srfi/srfi-146-hash-impl.scm
@@ -1,11 +1,11 @@
-(define hash-mapping-dtd
+(define hash-mapping-dto
   (let ()
 
-    (define (prep-dtd-arg proc)
-      (lambda (dtd . args)
+    (define (prep-dto-arg proc)
+      (lambda (dto . args)
         (apply proc args)))
 
-    (define (hashmap-alter* dtd dict key failure success)
+    (define (hashmap-find-update* dto dict key failure success)
       (call/cc
         ;; escape from whole hashmap-search entirely, when success / failure
         ;; return something other than through passed in continuation procedures
@@ -36,32 +36,32 @@
                                          (k result))))))
           new-dict)))
 
-    (make-dtd
-     dictionary?-id (prep-dtd-arg hashmap?)
+    (make-dto
+     dictionary?-id (prep-dto-arg hashmap?)
      dict-mutable?-id (lambda _ #f)
-     dict-empty?-id (prep-dtd-arg hashmap-empty?)
-     dict-contains?-id (prep-dtd-arg hashmap-contains?)
-     dict-ref-id (prep-dtd-arg hashmap-ref)
-     dict-ref/default-id (prep-dtd-arg hashmap-ref/default)
-     dict-set-id (prep-dtd-arg hashmap-set)
-     dict-adjoin-id (prep-dtd-arg hashmap-adjoin)
-     dict-delete-id (prep-dtd-arg hashmap-delete)
-     dict-delete-all-id (prep-dtd-arg hashmap-delete-all)
-     dict-replace-id (prep-dtd-arg hashmap-replace)
-     dict-intern-id (prep-dtd-arg hashmap-intern)
-     dict-update-id (prep-dtd-arg hashmap-update)
-     dict-update/default-id (prep-dtd-arg hashmap-update/default)
-     dict-pop-id (prep-dtd-arg hashmap-pop)
-     dict-filter-id (prep-dtd-arg hashmap-filter)
-     dict-remove-id (prep-dtd-arg hashmap-remove)
-     dict-alter-id hashmap-alter*
-     dict-size-id (prep-dtd-arg hashmap-size)
-     dict-for-each-id (prep-dtd-arg hashmap-for-each)
-     dict-count-id (prep-dtd-arg hashmap-count)
-     dict-keys-id (prep-dtd-arg hashmap-keys)
-     dict-values-id (prep-dtd-arg hashmap-values)
-     dict-entries-id (prep-dtd-arg hashmap-entries)
-     dict-fold-id (prep-dtd-arg hashmap-fold)
-     dict-map->list-id (prep-dtd-arg hashmap-map->list)
-     dict->alist-id (prep-dtd-arg hashmap->alist)
-     dict-comparator-id (prep-dtd-arg hashmap-key-comparator))))
+     dict-empty?-id (prep-dto-arg hashmap-empty?)
+     dict-contains?-id (prep-dto-arg hashmap-contains?)
+     dict-ref-id (prep-dto-arg hashmap-ref)
+     dict-ref/default-id (prep-dto-arg hashmap-ref/default)
+     dict-set-id (prep-dto-arg hashmap-set)
+     dict-adjoin-id (prep-dto-arg hashmap-adjoin)
+     dict-delete-id (prep-dto-arg hashmap-delete)
+     dict-delete-all-id (prep-dto-arg hashmap-delete-all)
+     dict-replace-id (prep-dto-arg hashmap-replace)
+     dict-intern-id (prep-dto-arg hashmap-intern)
+     dict-update-id (prep-dto-arg hashmap-update)
+     dict-update/default-id (prep-dto-arg hashmap-update/default)
+     dict-pop-id (prep-dto-arg hashmap-pop)
+     dict-filter-id (prep-dto-arg hashmap-filter)
+     dict-remove-id (prep-dto-arg hashmap-remove)
+     dict-find-update-id hashmap-find-update*
+     dict-size-id (prep-dto-arg hashmap-size)
+     dict-for-each-id (prep-dto-arg hashmap-for-each)
+     dict-count-id (prep-dto-arg hashmap-count)
+     dict-keys-id (prep-dto-arg hashmap-keys)
+     dict-values-id (prep-dto-arg hashmap-values)
+     dict-entries-id (prep-dto-arg hashmap-entries)
+     dict-fold-id (prep-dto-arg hashmap-fold)
+     dict-map->list-id (prep-dto-arg hashmap-map->list)
+     dict->alist-id (prep-dto-arg hashmap->alist)
+     dict-comparator-id (prep-dto-arg hashmap-key-comparator))))
diff --git a/srfi/srfi-146-impl.scm b/srfi/srfi-146-impl.scm
index b504e5f..ad6b629 100644
--- a/srfi/srfi-146-impl.scm
+++ b/srfi/srfi-146-impl.scm
@@ -1,11 +1,11 @@
-(define mapping-dtd
+(define mapping-dto
   (let ()
 
-    (define (prep-dtd-arg proc)
-      (lambda (dtd . args)
+    (define (prep-dto-arg proc)
+      (lambda (dto . args)
         (apply proc args)))
 
-    (define (mapping-alter* dtd dict key failure success)
+    (define (mapping-find-update* dto dict key failure success)
       (call/cc
         ;; escape from whole hashmap-search entirely, when success / failure
         ;; return something other than through passed in continuation procedures
@@ -36,32 +36,32 @@
                                          (k result))))))
           new-dict)))
 
-    (make-dtd
-     dictionary?-id (prep-dtd-arg mapping?)
+    (make-dto
+     dictionary?-id (prep-dto-arg mapping?)
      dict-mutable?-id (lambda _ #f)
-     dict-empty?-id (prep-dtd-arg mapping-empty?)
-     dict-contains?-id (prep-dtd-arg mapping-contains?)
-     dict-ref-id (prep-dtd-arg mapping-ref)
-     dict-ref/default-id (prep-dtd-arg mapping-ref/default)
-     dict-set-id (prep-dtd-arg mapping-set)
-     dict-adjoin-id (prep-dtd-arg mapping-adjoin)
-     dict-delete-id (prep-dtd-arg mapping-delete)
-     dict-delete-all-id (prep-dtd-arg mapping-delete-all)
-     dict-replace-id (prep-dtd-arg mapping-replace)
-     dict-intern-id (prep-dtd-arg mapping-intern)
-     dict-update-id (prep-dtd-arg mapping-update)
-     dict-update/default-id (prep-dtd-arg mapping-update/default)
-     dict-pop-id (prep-dtd-arg mapping-pop)
-     dict-filter-id (prep-dtd-arg mapping-filter)
-     dict-remove-id (prep-dtd-arg mapping-remove)
-     dict-alter-id mapping-alter*
-     dict-size-id (prep-dtd-arg mapping-size)
-     dict-for-each-id (prep-dtd-arg mapping-for-each)
-     dict-count-id (prep-dtd-arg mapping-count)
-     dict-keys-id (prep-dtd-arg mapping-keys)
-     dict-values-id (prep-dtd-arg mapping-values)
-     dict-entries-id (prep-dtd-arg mapping-entries)
-     dict-fold-id (prep-dtd-arg mapping-fold)
-     dict-map->list-id (prep-dtd-arg mapping-map->list)
-     dict->alist-id (prep-dtd-arg mapping->alist)
-     dict-comparator-id (prep-dtd-arg mapping-key-comparator))))
+     dict-empty?-id (prep-dto-arg mapping-empty?)
+     dict-contains?-id (prep-dto-arg mapping-contains?)
+     dict-ref-id (prep-dto-arg mapping-ref)
+     dict-ref/default-id (prep-dto-arg mapping-ref/default)
+     dict-set-id (prep-dto-arg mapping-set)
+     dict-adjoin-id (prep-dto-arg mapping-adjoin)
+     dict-delete-id (prep-dto-arg mapping-delete)
+     dict-delete-all-id (prep-dto-arg mapping-delete-all)
+     dict-replace-id (prep-dto-arg mapping-replace)
+     dict-intern-id (prep-dto-arg mapping-intern)
+     dict-update-id (prep-dto-arg mapping-update)
+     dict-update/default-id (prep-dto-arg mapping-update/default)
+     dict-pop-id (prep-dto-arg mapping-pop)
+     dict-filter-id (prep-dto-arg mapping-filter)
+     dict-remove-id (prep-dto-arg mapping-remove)
+     dict-find-update-id mapping-find-update*
+     dict-size-id (prep-dto-arg mapping-size)
+     dict-for-each-id (prep-dto-arg mapping-for-each)
+     dict-count-id (prep-dto-arg mapping-count)
+     dict-keys-id (prep-dto-arg mapping-keys)
+     dict-values-id (prep-dto-arg mapping-values)
+     dict-entries-id (prep-dto-arg mapping-entries)
+     dict-fold-id (prep-dto-arg mapping-fold)
+     dict-map->list-id (prep-dto-arg mapping-map->list)
+     dict->alist-id (prep-dto-arg mapping->alist)
+     dict-comparator-id (prep-dto-arg mapping-key-comparator))))
diff --git a/srfi/srfi-69-impl.scm b/srfi/srfi-69-impl.scm
index 734c6b4..c61036e 100644
--- a/srfi/srfi-69-impl.scm
+++ b/srfi/srfi-69-impl.scm
@@ -1,21 +1,21 @@
-(define srfi-69-dtd
+(define srfi-69-dto
   (let ()
 
-    (define (prep-dtd-arg proc)
-      (lambda (dtd . args)
+    (define (prep-dto-arg proc)
+      (lambda (dto . args)
         (apply proc args)))
 
-    (define (t69-hash-table-mutable?* dtd table)
+    (define (t69-hash-table-mutable?* dto table)
       #t)
 
-    (define (t69-hash-table-ref* dtd table key fail success)
+    (define (t69-hash-table-ref* dto table key fail success)
       (define default (cons #f #f))
       (define found (t69-hash-table-ref/default table key default))
       (if (eq? found default)
           (fail)
           (success found)))
 
-    (define (t69-hash-table-set!* dtd table . obj)
+    (define (t69-hash-table-set!* dto table . obj)
       (let loop ((obj obj))
         (if (null? obj)
             table
@@ -23,36 +23,36 @@
               (t69-hash-table-set! table (car obj) (cadr obj))
               (loop (cddr obj))))))
 
-    (define (t69-hash-table-update!/default* dtd table key proc default)
+    (define (t69-hash-table-update!/default* dto table key proc default)
       (t69-hash-table-update!/default table key proc default)
       table)
 
-    (define (t69-hash-table-delete-all!* dtd table keys)
+    (define (t69-hash-table-delete-all!* dto table keys)
       (for-each
        (lambda (key)
          (t69-hash-table-delete! table key))
        keys)
       table)
 
-    (define (t69-hash-table-foreach* dtd proc table)
+    (define (t69-hash-table-foreach* dto proc table)
       (t69-hash-table-walk table proc))
 
-    (define (t69-hash-table-map!* dtd proc table)
+    (define (t69-hash-table-map!* dto proc table)
       (t69-hash-table-walk table (lambda (key value)
                                (t69-hash-table-set! table key (proc key value))))
       table)
 
-    (define (t69-hash-table-filter!* dtd proc table)
+    (define (t69-hash-table-filter!* dto proc table)
       (t69-hash-table-walk table
                        (lambda (key value)
                          (unless (proc key value)
                            (t69-hash-table-delete! table key))))
       table)
 
-    (define (t69-hash-table-fold* dtd proc knil table)
+    (define (t69-hash-table-fold* dto proc knil table)
       (t69-hash-table-fold table proc knil))
 
-    (define (t69-hash-table-alter!* dtd table key fail success)
+    (define (t69-hash-table-find-update!* dto table key fail success)
       (define (handle-success value)
         (define (update new-key new-value)
           (unless (eq? new-key key)
@@ -77,29 +77,29 @@
           (handle-fail)
           (handle-success found)))
 
-    (define (t69-hash-table-comparator* dtd table)
+    (define (t69-hash-table-comparator* dto table)
       (make-comparator (lambda args #t)
                        (or (t69-hash-table-equivalence-function table)
                            equal?)
                        #f
                        (t69-hash-table-hash-function table)))
 
-    (make-dtd
-     dictionary?-id (prep-dtd-arg t69-hash-table?)
+    (make-dto
+     dictionary?-id (prep-dto-arg t69-hash-table?)
      dict-mutable?-id t69-hash-table-mutable?*
      dict-ref-id t69-hash-table-ref*
-     dict-ref/default-id (prep-dtd-arg t69-hash-table-ref/default)
+     dict-ref/default-id (prep-dto-arg t69-hash-table-ref/default)
      dict-set-id t69-hash-table-set!*
      dict-delete-all-id t69-hash-table-delete-all!*
-     dict-contains?-id (prep-dtd-arg t69-hash-table-exists?)
+     dict-contains?-id (prep-dto-arg t69-hash-table-exists?)
      dict-update/default-id t69-hash-table-update!/default*
-     dict-size-id (prep-dtd-arg t69-hash-table-size)
-     dict-keys-id (prep-dtd-arg t69-hash-table-keys)
-     dict-values-id (prep-dtd-arg t69-hash-table-values)
+     dict-size-id (prep-dto-arg t69-hash-table-size)
+     dict-keys-id (prep-dto-arg t69-hash-table-keys)
+     dict-values-id (prep-dto-arg t69-hash-table-values)
      dict-map-id t69-hash-table-map!*
      dict-filter-id t69-hash-table-filter!*
      dict-for-each-id t69-hash-table-foreach*
      dict-fold-id t69-hash-table-fold*
-     dict->alist-id (prep-dtd-arg t69-hash-table->alist)
-     dict-alter-id t69-hash-table-alter!*
+     dict->alist-id (prep-dto-arg t69-hash-table->alist)
+     dict-find-update-id t69-hash-table-find-update!*
      dict-comparator-id t69-hash-table-comparator*)))