rename new -> new-sequence

diff --git a/core/arrays/arrays.factor b/core/arrays/arrays.factor
index 414c64581e14cb29a0c28ffd1620b391cd8ee762..9c5f40d88327f3d2fc4d1686cfca22e207a45694 100755 (executable)
--- a/core/arrays/arrays.factor
+++ b/core/arrays/arrays.factor
@@ -12,9 +12,9 @@ M: array resize resize-array ;
 
 : >array ( seq -- array ) { } clone-like ;
 
-M: object new drop f <array> ;
+M: object new-sequence drop f <array> ;
 
-M: f new drop dup zero? [ drop f ] [ f <array> ] if ;
+M: f new-sequence drop dup zero? [ drop f ] [ f <array> ] if ;
 
 M: array like drop dup array? [ >array ] unless ;
 

diff --git a/core/bit-arrays/bit-arrays.factor b/core/bit-arrays/bit-arrays.factor
index ee485d399ee65bba65bde6eef6fab4a0e1efe77a..ffb9f5d195d5d9b637a497b51aa51ab5c8136fa1 100755 (executable)
--- a/core/bit-arrays/bit-arrays.factor
+++ b/core/bit-arrays/bit-arrays.factor
@@ -43,7 +43,7 @@ M: bit-array clone (clone) ;
 
 M: bit-array like drop dup bit-array? [ >bit-array ] unless ;
 
-M: bit-array new drop <bit-array> ;
+M: bit-array new-sequence drop <bit-array> ;
 
 M: bit-array equal?
     over bit-array? [ sequence= ] [ 2drop f ] if ;

diff --git a/core/bit-vectors/bit-vectors.factor b/core/bit-vectors/bit-vectors.factor
index c418a24813ab773467234e56698e91d1cbf8a3d9..3949dc263222520039f7205e9ef7eeda8f7e897f 100755 (executable)
--- a/core/bit-vectors/bit-vectors.factor
+++ b/core/bit-vectors/bit-vectors.factor
@@ -22,7 +22,7 @@ M: bit-vector like
         [ dup length bit-array>vector ] [ >bit-vector ] if\r
     ] unless ;\r
 \r
-M: bit-vector new\r
+M: bit-vector new-sequence\r
     drop [ <bit-array> ] keep >fixnum bit-array>vector ;\r
 \r
 M: bit-vector equal?\r

diff --git a/core/bootstrap/compiler/compiler.factor b/core/bootstrap/compiler/compiler.factor
index 9e101126e6683ab4996d2d0efe84d4ed7eba843d..da3c634ebdb3a99a53d36f575c74d8cddd2efe68 100755 (executable)
--- a/core/bootstrap/compiler/compiler.factor
+++ b/core/bootstrap/compiler/compiler.factor
@@ -53,7 +53,7 @@ nl
 "." write flush
 
 {
-    new nth push pop peek
+    new-sequence nth push pop peek
 } compile
 
 "." write flush

diff --git a/core/byte-arrays/byte-arrays.factor b/core/byte-arrays/byte-arrays.factor
index 548c293e7ce08d6aacb0a0b8b330f502c6730018..d6034708102abf55812b929702621822f7e42615 100755 (executable)
--- a/core/byte-arrays/byte-arrays.factor
+++ b/core/byte-arrays/byte-arrays.factor
@@ -10,7 +10,7 @@ M: byte-array nth-unsafe swap >fixnum alien-unsigned-1 ;
 M: byte-array set-nth-unsafe swap >fixnum set-alien-unsigned-1 ;
 : >byte-array ( seq -- byte-array ) B{ } clone-like ; inline
 M: byte-array like drop dup byte-array? [ >byte-array ] unless ;
-M: byte-array new drop <byte-array> ;
+M: byte-array new-sequence drop <byte-array> ;
 
 M: byte-array equal?
     over byte-array? [ sequence= ] [ 2drop f ] if ;

diff --git a/core/byte-vectors/byte-vectors.factor b/core/byte-vectors/byte-vectors.factor
index 6a08f657a2d0d857e2195b0840ca70526cdbcf7f..9a0185319f2675e59c01280e397d23a260007f34 100755 (executable)
--- a/core/byte-vectors/byte-vectors.factor
+++ b/core/byte-vectors/byte-vectors.factor
@@ -22,7 +22,7 @@ M: byte-vector like
         [ dup length byte-array>vector ] [ >byte-vector ] if\r
     ] unless ;\r
 \r
-M: byte-vector new\r
+M: byte-vector new-sequence\r
     drop [ <byte-array> ] keep >fixnum byte-array>vector ;\r
 \r
 M: byte-vector equal?\r

diff --git a/core/float-arrays/float-arrays.factor b/core/float-arrays/float-arrays.factor
index 33302572de82f50ade60b8301ceabe3492496360..d25d447a469470a3b0a228d83cdb4e09d6c18f77 100755 (executable)
--- a/core/float-arrays/float-arrays.factor
+++ b/core/float-arrays/float-arrays.factor
@@ -24,7 +24,7 @@ M: float-array set-nth-unsafe
 M: float-array like
     drop dup float-array? [ >float-array ] unless ;
 
-M: float-array new drop 0.0 <float-array> ;
+M: float-array new-sequence drop 0.0 <float-array> ;
 
 M: float-array equal?
     over float-array? [ sequence= ] [ 2drop f ] if ;

diff --git a/core/float-vectors/float-vectors.factor b/core/float-vectors/float-vectors.factor
index 2b023985a4728dadbda77c9bc4b3f50444ca4407..11535e349e394ec48bfdf5a02d92707d5f018150 100755 (executable)
--- a/core/float-vectors/float-vectors.factor
+++ b/core/float-vectors/float-vectors.factor
@@ -22,7 +22,7 @@ M: float-vector like
         [ dup length float-array>vector ] [ >float-vector ] if\r
     ] unless ;\r
 \r
-M: float-vector new\r
+M: float-vector new-sequence\r
     drop [ 0.0 <float-array> ] keep >fixnum float-array>vector ;\r
 \r
 M: float-vector equal?\r

diff --git a/core/sbufs/sbufs.factor b/core/sbufs/sbufs.factor
index 9de57c0801b21ed034bccb8676e32c3b5571efe4..69cbad2cd3c3bfab988d755f39110b4eadb5bbbb 100755 (executable)
--- a/core/sbufs/sbufs.factor
+++ b/core/sbufs/sbufs.factor
@@ -16,7 +16,7 @@ PRIVATE>
 M: sbuf set-nth-unsafe
     underlying >r >r >fixnum r> >fixnum r> set-string-nth ;
 
-M: sbuf new drop [ 0 <string> ] keep >fixnum string>sbuf ;
+M: sbuf new-sequence drop [ 0 <string> ] keep >fixnum string>sbuf ;
 
 : >sbuf ( seq -- sbuf ) SBUF" " clone-like ; inline
 

diff --git a/core/sequences/sequences-docs.factor b/core/sequences/sequences-docs.factor
index 473aa03d7a2db7cfd08b23b58ff099c2a9df841e..b7ad22996f5f63cae664e508cdf5f88b513a9197 100755 (executable)
--- a/core/sequences/sequences-docs.factor
+++ b/core/sequences/sequences-docs.factor
@@ -33,7 +33,7 @@ ARTICLE: "sequence-protocol" "Sequence protocol"
 "An optional generic word for creating sequences of the same class as a given sequence:"
 { $subsection like }
 "Optional generic words for optimization purposes:"
-{ $subsection new }
+{ $subsection new-sequence }
 { $subsection new-resizable }
 { $see-also "sequences-unsafe" } ;
 
@@ -281,7 +281,7 @@ HELP: immutable
 { $description "Throws an " { $link immutable } " error." }
 { $error-description "Thrown if an attempt is made to modify an immutable sequence." } ;
 
-HELP: new
+HELP: new-sequence
 { $values { "len" "a non-negative integer" } { "seq" sequence } { "newseq" "a mutable sequence" } }
 { $contract "Outputs a mutable sequence of length " { $snippet "n" } " which can hold the elements of " { $snippet "seq" } "." } ;
 

diff --git a/core/sequences/sequences.factor b/core/sequences/sequences.factor
index 996aba8e6e1a6ae2bafac9992b62ba2e5e3f710e..7061ac39336645942da9cb0ed0a0c7adf5f14329 100755 (executable)
--- a/core/sequences/sequences.factor
+++ b/core/sequences/sequences.factor
@@ -9,13 +9,13 @@ GENERIC: length ( seq -- n ) flushable
 GENERIC: set-length ( n seq -- )
 GENERIC: nth ( n seq -- elt ) flushable
 GENERIC: set-nth ( elt n seq -- )
-GENERIC: new ( len seq -- newseq ) flushable
+GENERIC: new-sequence ( len seq -- newseq ) flushable
 GENERIC: new-resizable ( len seq -- newseq ) flushable
 GENERIC: like ( seq exemplar -- newseq ) flushable
 GENERIC: clone-like ( seq exemplar -- newseq ) flushable
 
 : new-like ( len exemplar quot -- seq )
-    over >r >r new r> call r> like ; inline
+    over >r >r new-sequence r> call r> like ; inline
 
 M: sequence like drop ;
 
@@ -162,7 +162,7 @@ M: virtual-sequence set-nth virtual@ set-nth ;
 M: virtual-sequence nth-unsafe virtual@ nth-unsafe ;
 M: virtual-sequence set-nth-unsafe virtual@ set-nth-unsafe ;
 M: virtual-sequence like virtual-seq like ;
-M: virtual-sequence new virtual-seq new ;
+M: virtual-sequence new-sequence virtual-seq new-sequence ;
 
 INSTANCE: virtual-sequence sequence
 
@@ -250,7 +250,7 @@ INSTANCE: repetition immutable-sequence
     dup 0 <= [ 2drop 2drop ] [ 1- ((copy)) (copy) ] if ; inline
 
 : prepare-subseq ( from to seq -- dst i src j n )
-    [ >r swap - r> new dup 0 ] 3keep
+    [ >r swap - r> new-sequence dup 0 ] 3keep
     -rot drop roll length ; inline
 
 : check-copy ( src n dst -- )
@@ -275,7 +275,7 @@ PRIVATE>
     (copy) drop ; inline
 
 M: sequence clone-like
-    >r dup length r> new [ 0 swap copy ] keep ;
+    >r dup length r> new-sequence [ 0 swap copy ] keep ;
 
 M: immutable-sequence clone-like like ;
 

diff --git a/core/strings/strings.factor b/core/strings/strings.factor
index bb3c94ce97824bcb236d6c84cce40c9823376543..14847372778a8ea83026dfe29a31972d6b36563a 100755 (executable)
--- a/core/strings/strings.factor
+++ b/core/strings/strings.factor
@@ -46,6 +46,6 @@ M: string resize resize-string ;
 
 : >string ( seq -- str ) "" clone-like ;
 
-M: string new drop 0 <string> ;
+M: string new-sequence drop 0 <string> ;
 
 INSTANCE: string sequence

diff --git a/core/vectors/vectors.factor b/core/vectors/vectors.factor
index 1820c62ff45ecab41ecd28bdb64f33b4a6b6234b..aa827fd7268e264834d1e7700c462e83554d99c6 100755 (executable)
--- a/core/vectors/vectors.factor
+++ b/core/vectors/vectors.factor
@@ -19,7 +19,7 @@ M: vector like
         dup array? [ dup length array>vector ] [ >vector ] if
     ] unless ;
 
-M: vector new drop [ f <array> ] keep >fixnum array>vector ;
+M: vector new-sequence drop [ f <array> ] keep >fixnum array>vector ;
 
 M: vector equal?
     over vector? [ sequence= ] [ 2drop f ] if ;

diff --git a/extra/sequences/next/next.factor b/extra/sequences/next/next.factor
index 5919fb0701f6497e7b83640c4127885f63976483..b22bf2683c78031486ff306cbe58165b6b21b08d 100755 (executable)
--- a/extra/sequences/next/next.factor
+++ b/extra/sequences/next/next.factor
@@ -17,6 +17,6 @@ PRIVATE>
 
 : map-next ( seq quot -- newseq )
     ! quot: next-elt elt -- newelt
-    over dup length swap new >r
+    over dup length swap new-sequence >r
     iterate-seq [ (map-next) ] 2curry
     r> [ collect ] keep ; inline