* boot/ast.boot (shoeCompTran1): Translate extended vector-forms.

	* interp/c-util.boot: Use vector instead of LIST2VEC.
	* interp/define.boot: Likewise.
	* interp/i-coerce.boot: Likewise.
	* interp/i-coerfn.boot: Likewise.
	* interp/i-funsel.boot: Likewise.
	* interp/i-map.boot: Likewise.
	* interp/i-special.boot: Likewise.
	* interp/interop.boot: Likewise.
	* interp/nruncomp.boot: Likewise.
	* interp/slam.boot: Likewise.

10 files changed, 47 insertions, 49 deletions

diff --git a/src/interp/c-util.boot b/src/interp/c-util.boot
index 1d281ea8..f7fd2dc4 100644
--- a/src/interp/c-util.boot
+++ b/src/interp/c-util.boot
@@ -1041,7 +1041,7 @@ sublisV(p,e) ==
     suba(p,e) ==
       string? e => e
       -- no need to descend vectors unless they are categories
-      categoryObject? e => LIST2VEC [suba(p,e.i) for i in 0..maxIndex e]
+      categoryObject? e => vector [suba(p,e.i) for i in 0..maxIndex e]
       e isnt [.,:.] => (y:= ASSQ(e,p) => rest y; e)
       u:= suba(p,first e)
       v:= suba(p,rest e)
diff --git a/src/interp/define.boot b/src/interp/define.boot
index 8df914ac..e0b0aae1 100644
--- a/src/interp/define.boot
+++ b/src/interp/define.boot
@@ -165,7 +165,7 @@ makeCompactDirect u ==
   --pp opList 
   d := [[op,y] for [op,:items] in opList | y := makeCompactDirect1(op,items)]
   $byteVec := [:$byteVec,:"append"/reverse! $byteVecAcc]
-  LIST2VEC ("append"/d)
+  vector("append"/d)
  
 makeCompactDirect1(op,items) ==
 --NOTES: creates byte codes for ops implemented by the domain
@@ -248,8 +248,8 @@ NRTmakeCategoryAlist() ==
   catformvec := ASSOCLEFT slot1
   maxElement := "MAX"/$byteVec
   ['CONS, ['makeByteWordVec2,MAX(maxPredList,1),MKQ predList],
-    ['CONS, MKQ LIST2VEC slot0,
-      ['CONS, MKQ LIST2VEC [encodeCatform x for x in catformvec],
+    ['CONS, MKQ vector slot0,
+      ['CONS, MKQ vector [encodeCatform x for x in catformvec],
         ['makeByteWordVec2,maxElement,MKQ $byteVec]]]]
   --NOTE: this is new form: old form satisfies vector? CDDR form
 
diff --git a/src/interp/i-coerce.boot b/src/interp/i-coerce.boot
index cdb40620..2c7e4283 100644
--- a/src/interp/i-coerce.boot
+++ b/src/interp/i-coerce.boot
@@ -1213,7 +1213,7 @@ computeTTTranspositions(t1,t2) ==
   -- create a list of permutations that transform the tower parts
   -- of t1 into the order they are in in t2
   n1 := #tl1
-  p2 := LIST2VEC compress(p2,0,# removeDuplicates tl1) where
+  p2 := vector compress(p2,0,# removeDuplicates tl1) where
     compress(l,start,len) ==
       start >= len => l
       member(start,l) => compress(l,start+1,len)
@@ -1223,7 +1223,7 @@ computeTTTranspositions(t1,t2) ==
   -- them
   perms := permuteToOrder(p2,n1-1,0)
   towers := [tl1]
-  tower := LIST2VEC tl1
+  tower := vector tl1
   for perm in perms repeat
     t := tower.(first perm)
     tower.(first perm) := tower.(rest perm)
diff --git a/src/interp/i-coerfn.boot b/src/interp/i-coerfn.boot
index b2d46aee..a8409b09 100644
--- a/src/interp/i-coerfn.boot
+++ b/src/interp/i-coerfn.boot
@@ -1,6 +1,6 @@
 -- Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
 -- All rights reserved.
--- Copyright (C) 2007-2010, Gabriel Dos Reis.
+-- Copyright (C) 2007-2011, Gabriel Dos Reis.
 -- All rights reserved.
 --
 -- Redistribution and use in source and binary forms, with or without
@@ -62,7 +62,7 @@ Dmp2Dmp(u,source is [dmp,v1,S], target is [.,v2,T]) ==
       t2:= if w2 then [dmp,w2,T] else T
       canCoerce(t1,t2)
   null u => domainZero(target)
-  u is [[e,:c]] and e=LIST2VEC [0 for v in v1] =>
+  u is [[e,:c]] and e = vector [0 for v in v1] =>
     z:= coerceInt(objNewWrap(c,S),target) => objValUnwrap(z)
     coercionFailure()
   v:= intersection(v1,v2) =>
@@ -83,10 +83,10 @@ coerceDmp1(u,source is [.,v1,S],target is [.,v2,T],v,w) ==
   pat2:= [member(x,w) for x in v1]
   pat3:= [member(x,v) and POSN1(x,v) for x in v2]
   for [e,:c] in u until not z repeat
-    exp:= LIST2VEC [y for x in pat2 for y in VEC2LIST e | x]
+    exp := vector [y for x in pat2 for y in VEC2LIST e | x]
     z:= coerceInt(objNewWrap([[exp,:c]],t),target) =>
       li:= [y for x in pat1 for y in VEC2LIST e | x]
-      a:= [[LIST2VEC [if x then li.x else 0 for x in pat3],:one]]
+      a:= [[vector [if x then li.x else 0 for x in pat3],:one]]
       x:= SPADCALL(x,SPADCALL(objValUnwrap(z),a,multfunc),plusfunc)
   z => x
   coercionFailure()
@@ -101,7 +101,7 @@ coerceDmp2(u,source is [.,v1,S],target is [.,v2,T]) ==
   for [e,:c] in u until not z repeat
     z:= coerceInt(objNewWrap(c,S),target) =>
       li:= VEC2LIST e
-      a:= [[LIST2VEC [if x then li.x else 0 for x in pat],:one]]
+      a:= [[vector [if x then li.x else 0 for x in pat],:one]]
       x:= SPADCALL(x,SPADCALL(objValUnwrap(z),a,multfunc),plusfunc)
     nil
   z => x
@@ -173,11 +173,11 @@ coerceDmpCoeffs(u,S,T) ==
 sortAndReorderDmpExponents(u,vl) ==
   vl' := reverse MSORT vl
   n := (-1) + #vl
-  pos := LIST2VEC LZeros (n+1)
+  pos := vector LZeros (n+1)
   for i in 0..n repeat pos.i := position(vl.i,vl')
   u' := nil
   for [e,:c] in u repeat
-    e' := LIST2VEC LZeros (n+1)
+    e' := vector LZeros (n+1)
     for i in 0..n repeat e'.(pos.i) := e.i
     u' := [[e',:c],:u']
   reverse u'
@@ -313,7 +313,7 @@ Dmp2Up(u, source is [dmp,vl,S],target is [up,var,T]) ==
 
 removeVectorElt(v,pos) ==
   -- removes the pos'th element from vector v
-  LIST2VEC [x for x in VEC2LIST v for y in 0.. | not (y=pos)]
+  vector [x for x in VEC2LIST v for y in 0.. | y ~= pos]
 
 removeListElt(l,pos) ==
   pos = 0 => rest l
@@ -365,7 +365,7 @@ Expr2Dmp(u,source is [Expr,S], target is [dmp,v2,T]) ==
 
     null v2 =>
         not (z := coerceInt(objNewWrap(u, source), T)) => coercionFailure()
-        [[LIST2VEC nil, :objValUnwrap z]]
+        [[vector [], :objValUnwrap z]]
 
     obj := objNewWrap(u, source)
     univ := coerceInt(obj, ['UnivariatePolynomial, first v2, T])
@@ -394,7 +394,7 @@ Expr2Dmp(u,source is [Expr,S], target is [dmp,v2,T]) ==
     summands := nil
     for [e,:c] in univ repeat
         summands := Expr2Dmp1(summands,
-            LIST2VEC [e, :[0 for v in rest v2]], c, T, 1, rest v2, T)
+            vector [e, :[0 for v in rest v2]], c, T, 1, rest v2, T)
 
     plus := getFunctionFromDomain("+", target, [target, target])
     sum  := domainZero target
@@ -492,7 +492,7 @@ Factored2Factored(u,oldmode,newmode) ==
 coerceFFE(ffe, oldmode, newmode) ==
   fac' := coerceInt(objNewWrap(ffe.1,oldmode),newmode)
   null fac' => 'failed
-  LIST2VEC [ffe.0,objValUnwrap(fac'),ffe.2]
+  vector [ffe.0,objValUnwrap(fac'),ffe.2]
 
 --% Complex
 
@@ -572,7 +572,7 @@ L2DP(l, source is [.,S], target is [.,n,T]) ==
   -- need to know size of the list
   l = '_$fromCoerceable_$ => nil
   n ~= # l => coercionFailure()
-  (v := coerceInt(objNewWrap(LIST2VEC l,['Vector,S]),['Vector,T])) or
+  (v := coerceInt(objNewWrap(vector l,['Vector,S]),['Vector,T])) or
     coercionFailure()
   V2DP(objValUnwrap v, ['Vector, T], target)
 
@@ -587,7 +587,7 @@ V2DP(v, source is [.,S], target is [.,n,T]) ==
 
 L2V(l, source is [.,S], target is [.,T]) ==
   l = '_$fromCoerceable_$ => canCoerce(S,T)
-  (v := coerceInt(objNewWrap(LIST2VEC l,['Vector,S]),target)) or
+  (v := coerceInt(objNewWrap(vector l,['Vector,S]),target)) or
     coercionFailure()
   objValUnwrap(v)
 
@@ -606,8 +606,8 @@ L2M(u,[.,D],[.,R]) ==
       for y in x repeat
         (y' := coerceInt(objNewWrap(y,E),R)) or coercionFailure()
         x' := [objValUnwrap(y'),:x']
-      u' := [LIST2VEC reverse x',:u']
-    LIST2VEC reverse u'
+      u' := [vector reverse x',:u']
+    vector reverse u'
   coercionFailure()
 
 L2Record(l,[.,D],[.,:al]) ==
@@ -616,9 +616,9 @@ L2Record(l,[.,D],[.,:al]) ==
     v:= [u for x in l for [":",.,D'] in al] where u() ==
       T:= coerceInt(objNewWrap(x,D),D') or return 'failed
       objValUnwrap(T)
-    v = 'failed => coercionFailure()
+    v is 'failed => coercionFailure()
     #v = 2 => [v.0,:v.1]
-    LIST2VEC v
+    vector v
   coercionFailure()
 
 L2Rm(u,source is [.,D],target is [.,n,m,R]) ==
@@ -693,8 +693,8 @@ M2M(x,[.,R],[.,S]) ==
       y := x.i.j
       (y' := coerceInt(objNewWrap(y,R),S)) or coercionFailure()
       u := [objValUnwrap y',:u]
-    v := [LIST2VEC reverse u,:v]
-  LIST2VEC reverse v
+    v := [vector reverse u,:v]
+  vector reverse v
 
 M2Rm(x,source is [.,R],[.,p,q,S]) ==
   x = '_$fromCoerceable_$ => nil
@@ -741,11 +741,11 @@ Mp2Dmp(u, source is [., x, S], target is [dmp, y, T]) ==
 Mp2SimilarDmp(u,S,n,plus,mult,one,zero) ==
   u is [ =0,:c] =>
     c = zero => nil  -- zero for dmp
-    [[LIST2VEC LZeros n,:c]]
+    [[vector LZeros n,:c]]
   u is [ =1,x,:terms] =>
     u' := nil  -- zero for dmp
     for [e,:c] in terms repeat
-      e' := LIST2VEC LZeros n
+      e' := vector LZeros n
       e'.(x-1) := e
       t := [[e',:one]]
       t := SPADCALL(t,Mp2SimilarDmp(c,S,n,plus,mult,one,zero),mult)
@@ -1320,7 +1320,7 @@ Sy2Dmp(u,source,target is [dmp,vl,S]) ==
   u = '_$fromCoerceable_$ => canCoerce(source,S)
   len:= #vl
   -1 ~= (n:= position(u,vl)) =>
-    u:= wrap LIST [LIST2VEC [(n=i => 1; 0) for i in 0..len-1],:1]
+    u:= wrap LIST [vector [(n=i => 1; 0) for i in 0..len-1],:1]
     objValUnwrap(coerceInt(objNew(u,[dmp,vl,$Integer]),target))
   (u := coerceInt(objNewWrap(u,source),S)) or coercionFailure()
   [[Zeros len,:objValUnwrap u]]
@@ -1336,7 +1336,7 @@ Sy2NDmp(u,source,target is [ndmp,vl,S]) ==
   u = '_$fromCoerceable_$ => canCoerce(source,S)
   len:= #vl
   -1 ~= (n:= position(u,vl)) =>
-    u:= wrap LIST [LIST2VEC [(n=i => 1; 0) for i in 0..len-1],:1]
+    u:= wrap LIST [vector [(n=i => 1; 0) for i in 0..len-1],:1]
     objValUnwrap(coerceInt(objNew(u,[ndmp,vl,$Integer]),target))
   (u := coerceInt(objNewWrap(u,source),S)) or coercionFailure()
   [[Zeros len,:objValUnwrap(u)]]
@@ -1382,7 +1382,7 @@ Up2Dmp(u,source is ['UnivariatePolynomial,var,S],
     for [e,:c] in u until not z repeat
       z:= coerceInt(objNewWrap(c,S),target) =>
         y:= SPADCALL(objValUnwrap(z),
-          [[LIST2VEC [:l1,e,:l2],:one]],multfunc)
+          [[vector [:l1,e,:l2],:one]],multfunc)
         x:= SPADCALL(x,y,plusfunc)
     z => x
     coercionFailure()
@@ -1544,7 +1544,7 @@ Var2Dmp(u,source,target is [dmp,vl,S]) ==
 
   len := #vl
   -1 ~= (n:= position(sym,vl)) =>
-    LIST [LIST2VEC [(n=i => 1; 0) for i in 0..len-1],
+    LIST [vector [(n=i => 1; 0) for i in 0..len-1],
       :getConstantFromDomain($One,S)]
   (u := coerceInt(objNewWrap(u,source),S)) or coercionFailure()
   [[Zeros len,:objValUnwrap u]]
@@ -1555,7 +1555,7 @@ Var2Gdmp(u,source,target is [dmp,vl,S]) ==
 
   len := #vl
   -1 ~= (n:= position(sym,vl)) =>
-    LIST [LIST2VEC [(n=i => 1; 0) for i in 0..len-1],
+    LIST [vector [(n=i => 1; 0) for i in 0..len-1],
       :getConstantFromDomain($One,S)]
   (u := coerceInt(objNewWrap(u,source),S)) or coercionFailure()
   [[Zeros len,:objValUnwrap u]]
@@ -1574,7 +1574,7 @@ Var2NDmp(u,source,target is [ndmp,vl,S]) ==
 
   len:= #vl
   -1 ~= (n:= position(u,vl)) =>
-    LIST [LIST2VEC [(n=i => 1; 0) for i in 0..len-1],
+    LIST [vector [(n=i => 1; 0) for i in 0..len-1],
       :getConstantFromDomain($One,S)]
   (u := coerceInt(objNewWrap(u,source),S)) or coercionFailure()
   [[Zeros len,:objValUnwrap(u)]]
@@ -1652,27 +1652,25 @@ V2M(u,[.,D],[.,R]) ==
   -- first see if we are coercing a vector of vectors
   D is ['Vector,E] and
     isRectangularVector(u,maxIndex u,maxIndex u.0) =>
-      LIST2VEC
-        [LIST2VEC [objValUnwrap(coerceInt(objNewWrap(x.j,E),R))
+      vector
+        [vector [objValUnwrap(coerceInt(objNewWrap(x.j,E),R))
            for j in 0..maxIndex(x:=u.i)] for i in 0..maxIndex u]
   -- if not, try making it into a 1 by n matrix
   coercionFailure()
---LIST2VEC [LIST2VEC [objValUnwrap(coerceInt(objNewWrap(u.i,D),R))
---  for i in 0..maxIndex(u)]]
 
 V2Rm(u,[.,D],[.,n,m,R]) ==
   u = '_$fromCoerceable_$ => nil
   D is [.,E,:.] and isRectangularVector(u,n-1,m-1) =>
-    LIST2VEC
-      [LIST2VEC [objValUnwrap(coerceInt(objNewWrap(x.j,E),R))
+    vector
+      [vector [objValUnwrap(coerceInt(objNewWrap(x.j,E),R))
          for j in 0..maxIndex(x:=u.i)] for i in 0..maxIndex u]
   coercionFailure()
 
 V2Sm(u,[.,D],[.,n,R]) ==
   u = '_$fromCoerceable_$ => nil
   D is [.,E,:.] and isRectangularVector(u,n-1,n-1) =>
-    LIST2VEC
-      [LIST2VEC [objValUnwrap(coerceInt(objNewWrap(x.j,E),R))
+    vector
+      [vector [objValUnwrap(coerceInt(objNewWrap(x.j,E),R))
          for j in 0..maxIndex(x:=u.i)] for i in 0..maxIndex u]
   coercionFailure()
 
@@ -1755,7 +1753,7 @@ commuteQuaternion(u,source,S,target,T) ==
     or coercionFailure()) for x in VEC2LIST u]
   q := '(Quaternion (Integer))
   e := [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]
-  e := [(coerceInt(objNewWrap(LIST2VEC x,q),T)
+  e := [(coerceInt(objNewWrap(vector x,q),T)
     or coercionFailure()) for x in e]
   e :=[objValUnwrap(coerceInt(x,target) or coercionFailure()) for x in e]
   u' := domainZero(target)
@@ -1822,7 +1820,7 @@ commuteSquareMatrix(u,source,S,target,T) ==
 makeEijSquareMatrix(i, j, dim) ==
   -- assume using 0 based scale, makes a dim by dim matrix with a
   -- 1 in the i,j position, zeros elsewhere
-  LIST2VEC [LIST2VEC [((i=r) and (j=c) => 1; 0)
+  vector [vector [((i=r) and (j=c) => 1; 0)
     for c in 0..(dim-1)] for r in 0..(dim-1)]
 
 --% Univariate Polynomial and Sparse Univariate Polynomial
diff --git a/src/interp/i-funsel.boot b/src/interp/i-funsel.boot
index 16b58b74..2a086cf9 100644
--- a/src/interp/i-funsel.boot
+++ b/src/interp/i-funsel.boot
@@ -713,7 +713,7 @@ findCommonSigInDomain(opName,dom,nargs) ==
   vec := nil
   for mm in rest mmList repeat
     nargs = #first mm =>
-      null vec  => vec := LIST2VEC first mm
+      null vec  => vec := vector first mm
       for i in 0.. for x in first mm repeat
         if vec.i and vec.i ~= x then vec.i := nil
   VEC2LIST vec
diff --git a/src/interp/i-map.boot b/src/interp/i-map.boot
index 8538c304..75312782 100644
--- a/src/interp/i-map.boot
+++ b/src/interp/i-map.boot
@@ -774,7 +774,7 @@ compileCoerceMap(op,argTypes,mm) ==
   body := ['SPADCALL,:argCode,['LIST,['function,imp]]]
   minivectorName := makeInternalMapMinivectorName name
   body := substitute(["%dynval",MKQ minivectorName],"$$$",body)
-  symbolValue(minivectorName) := LIST2VEC $minivector
+  symbolValue(minivectorName) := vector $minivector
   compileInteractive [name,['LAMBDA,parms,body]]
   sig.target
 
diff --git a/src/interp/i-special.boot b/src/interp/i-special.boot
index 073c2cbd..ba2dbd61 100644
--- a/src/interp/i-special.boot
+++ b/src/interp/i-special.boot
@@ -155,7 +155,7 @@ compileADEFBody(t,vars,types,body,computedResultType) ==
   $compiledOpNameList := [$mapName]
   minivectorName := makeInternalMapMinivectorName symbolName $mapName
   body := substitute(["%dynval",MKQ minivectorName],"$$$",body)
-  symbolValue(minivectorName) := LIST2VEC $minivector
+  symbolValue(minivectorName) := vector $minivector
 
   -- The use of the three variables $definingMap, $genValue and $compilingMap
   -- is to cover the following cases:
diff --git a/src/interp/interop.boot b/src/interp/interop.boot
index 4d4f066e..6c009c64 100644
--- a/src/interp/interop.boot
+++ b/src/interp/interop.boot
@@ -190,7 +190,7 @@ oldAxiomPreCategoryParents(catform,dom) ==
   -- parents :=  getConstructorParentsFromDB opOf catform
   parents := parentsOf opOf catform
   PROGV(vars, vals,
-    LIST2VEC
+    vector
       [eval quoteCatOp cat for [cat,:pred] in parents | eval pred])
 
 quoteCatOp cat == 
diff --git a/src/interp/nruncomp.boot b/src/interp/nruncomp.boot
index 719476a4..873b9429 100644
--- a/src/interp/nruncomp.boot
+++ b/src/interp/nruncomp.boot
@@ -432,7 +432,7 @@ stuffDomainSlots dollar ==
     bitVector := domainPredicates dollar
     predvec := first proto4
     packagevec := second proto4
-    auxvec := LIST2VEC [fn for i in 0..maxIndex predvec] where fn() ==
+    auxvec := vector [fn for i in 0..maxIndex predvec] where fn() ==
       not testBitVector(bitVector,predvec.i) => nil
       packagevec.i or true
     [auxvec,:CDDR proto4]
diff --git a/src/interp/slam.boot b/src/interp/slam.boot
index f069dfb1..6bc36443 100644
--- a/src/interp/slam.boot
+++ b/src/interp/slam.boot
@@ -143,7 +143,7 @@ reportFunctionCompilation(op,nam,argl,body,isRecursive) ==
   $compiledOpNameList := [nam]
   minivectorName := makeInternalMapMinivectorName nam
   body := substitute(["%dynval",MKQ minivectorName],"$$$",body)
-  symbolValue(minivectorName) := LIST2VEC $minivector
+  symbolValue(minivectorName) := vector $minivector
   argl := COPY argl     -- play it safe for optimization
   init :=
     not(isRecursive and $compileRecurrence and #argl = 1) => nil