[dylan] <simple-stretchy-vector> -> <stretchy-object-vector>.

This reduces another point of difference between Open Dylan and
Mindy. (d2c also used the Open Dylan name.)

* libraries/dylan/stretchy.dylan: Rename <simple-stretchy-vector>
  to <stretchy-object-vector>.

* libraries/dylan/library.dylan
  (module extras): Export the name <stretchy-object-vector> as some
   libraries want to use it.

* tests/print/print-test.dylan
  (print-test): Remove "#if (mindy)" checks now that Mindy matches
   the other compilers.

libraries/dylan/library.dylan

@@ -148,7 +148,7 @@ define module extras
     <format-string-condition>, report-condition,
     condition-format, condition-force-output,
     ratio, integer-length, $unsupplied, false-or, instantiable?,
-    add-debug-variable;
+    add-debug-variable, <stretchy-object-vector>;
 end;
 
 

libraries/dylan/stretchy.dylan

@@ -40,24 +40,24 @@ end class <stretchy-vector>;
 
 define method make
     (cls == <stretchy-vector>, #rest keys, #key, #all-keys)
- => vec :: <simple-stretchy-vector>;
-  apply(make, <simple-stretchy-vector>, keys);
+ => vec :: <stretchy-object-vector>;
+  apply(make, <stretchy-object-vector>, keys);
 end method;
 
 
 
-//// <simple-stretchy-vector>
+//// <stretchy-object-vector>
 
-define class <simple-stretchy-vector> (<stretchy-vector>)
+define class <stretchy-object-vector> (<stretchy-vector>)
   slot ssv-data :: <simple-object-vector>, required-init-keyword: data:;
   slot ssv-fill :: <integer>, required-init-keyword: fill:;
-end class <simple-stretchy-vector>;
+end class <stretchy-object-vector>;
 
 
-define method make(cls == <simple-stretchy-vector>,
+define method make(cls == <stretchy-object-vector>,
                    #next next-method,
                    #key size: sz = #f, fill, dimensions)
- => vec :: <simple-stretchy-vector>;
+ => vec :: <stretchy-object-vector>;
   if (sz & dimensions)
     error("Can't supply both a size: and dimensions:");
   else
@@ -87,11 +87,11 @@ define method make(cls == <simple-stretchy-vector>,
   end if;
 end method make;
 
-define method size(ssv :: <simple-stretchy-vector>) => size :: <integer>;
+define method size(ssv :: <stretchy-object-vector>) => size :: <integer>;
   ssv-fill(ssv);
 end method size;
 
-define method size-setter(new :: <integer>, ssv :: <simple-stretchy-vector>)
+define method size-setter(new :: <integer>, ssv :: <stretchy-object-vector>)
  => new :: <integer>;
   let fill = ssv-fill(ssv);
   let data = ssv-data(ssv);
@@ -118,13 +118,13 @@ define method size-setter(new :: <integer>, ssv :: <simple-stretchy-vector>)
   ssv-fill(ssv) := new;
 end method size-setter;
 
-define method dimensions(ssv :: <simple-stretchy-vector>)
+define method dimensions(ssv :: <stretchy-object-vector>)
  => dimensions :: <list>;
   list(size(ssv));
 end method dimensions;
 
 
-define method element(ssv :: <simple-stretchy-vector>, key :: <integer>,
+define method element(ssv :: <stretchy-object-vector>, key :: <integer>,
                       #key default = $unsupplied)
  => elt :: <object>;
   case
@@ -137,7 +137,7 @@ define method element(ssv :: <simple-stretchy-vector>, key :: <integer>,
   end case;
 end method element;
 
-define method element-setter(value, ssv :: <simple-stretchy-vector>,
+define method element-setter(value, ssv :: <stretchy-object-vector>,
                              key :: <integer>)
  => value :: <object>;
   if (key < 0)
@@ -150,8 +150,8 @@ define method element-setter(value, ssv :: <simple-stretchy-vector>,
   end if;
 end method element-setter;
 
-define method add!(ssv :: <simple-stretchy-vector>, new-element)
- => ssv :: <simple-stretchy-vector>;
+define method add!(ssv :: <stretchy-object-vector>, new-element)
+ => ssv :: <stretchy-object-vector>;
   let data = ssv-data(ssv);
   let fill = size(ssv);
   if (fill = size(data))
@@ -171,9 +171,9 @@ define method add!(ssv :: <simple-stretchy-vector>, new-element)
   ssv;
 end method add!;
 
-define method remove!(ssv :: <simple-stretchy-vector>, elem,
+define method remove!(ssv :: <stretchy-object-vector>, elem,
                       #key test = \==, count)
- => ssv :: <simple-stretchy-vector>;
+ => ssv :: <stretchy-object-vector>;
   unless (count & (count = 0))
     let data = ssv-data(ssv);
     let sz = size(ssv);

tests/print/print-test.dylan

@@ -67,23 +67,13 @@ define method print-test () => ();
   run-test(print-to-string(eint), "#e-1", "extended-integer");
 
   let sequence-1 = make(<stretchy-vector>);
-#if (mindy)
-  run-test(print-to-string(sequence-1), "{<simple-stretchy-vector>: }",
-           "empty sequence");
-#else
   run-test(print-to-string(sequence-1), "{<stretchy-object-vector>: }",
            "empty sequence");
-#endif
 
   let sequence-2 = make(<stretchy-vector>, size: 5);
   sequence-2[3] := 3;
-#if (mindy)
-  run-test(print-to-string(sequence-2),
-           "{<simple-stretchy-vector>: #f, #f, #f, 3, #f}", "sequence");
-#else
   run-test(print-to-string(sequence-2),
            "{<stretchy-object-vector>: #f, #f, #f, 3, #f}", "sequence");
-#endif
 
   let sequence-3 = #[4, 5, 6, 2];
   run-test(print-to-string(sequence-3), "#[4, 5, 6, 2]", "vector");