Add several pairs-related methods

M2/Macaulay2/d/actors2.dd

@@ -104,7 +104,7 @@ values(e:Expr):Expr := (
      else WrongArg("a hash table or dictionary"));
 setupfun("values",values);
 
-pairs(e:Expr):Expr := (
+export pairs(e:Expr):Expr := (
      when e
      is oc:DictionaryClosure do (    -- # typical value: pairs, Dictionary, List
 	  o := oc.dictionary.symboltable;
@@ -142,8 +142,13 @@ pairs(e:Expr):Expr := (
 	    while i < length(o) do (
 	      provide Expr(Sequence(toExpr(i),o.i));
 	      i = i+1;)))
-     is o:List do pairs(Expr(o.v))   -- # typical value: pairs, BasicList, List
-     else WrongArg("a hash table, a sequence, a list, or a raw polynomial"));
+     -- # typical value: pairs, BasicList, List
+     is o:List do (
+	 r := pairs(Expr(o.v));
+	 when r
+	 is s:Sequence do list(o.Class, s, o.Mutable)
+	 else buildErrorPacket("internal error; expected a sequence"))
+     else applyEE(getGlobalVariable(pairsIteratorS), e)); -- # typical value: pairs, Thing, Iterator
 setupfun("pairs",pairs);
 
 -- operators

M2/Macaulay2/d/actors3.d

@@ -2,6 +2,7 @@
 
 use evaluate;
 use actors;
+use actors2;
 use ballarith;
 
 isOption(e:Expr):bool := (
@@ -82,7 +83,7 @@ override(e:Expr):Expr := (
 	  if length(args) == 2 then (
 	       when args.0
 	       is h:HashTable do (
-		    if h.Mutable then WrongArg("an immutable hash table")
+		    if h.Mutable then WrongArgImmutableHashTable()
 		    else when args.1 is v:Sequence do override(h,v,numOptions(v))
 		    else override(h,Sequence(args.1),if isOption(args.1) then 1 else 0)
 		    )
@@ -1895,6 +1896,22 @@ map(e:Expr):Expr := (
      else WrongNumArgs(2,3));
 setupfun("apply",map);
 
+applyPairs(e:Expr):Expr := (
+    when e
+    is a:Sequence do (
+	if length(a) == 2 then (
+	    when a.0
+	    is o:HashTable do (
+		if o.Mutable then WrongArgImmutableHashTable(1)
+		else mappairs(a.1, o))
+	    -- # typical value: applyPairs, BasicList, Function, List
+	    -- # typical value: applyPairs, Dictionary, Function, List
+	    -- # typical value: applyPairs, Thing, Function, Iterator
+	    else map(pairs(a.0), a.1))
+	else WrongNumArgs(2))
+    else WrongNumArgs(2));
+setupfun("applyPairs", applyPairs);
+
 -- # typical value: scan, ZZ, Function, Thing
 scan(n:int,f:Expr):Expr := (
      if n <= 0 then return nullE;
@@ -2346,6 +2363,20 @@ scan(e:Expr):Expr := (
      else WrongNumArgs(2));
 setupfun("scan",scan);
 
+-- # typical value: scanPairs, Thing, Function, Nothing
+scanPairs(e:Expr):Expr := (
+    when e
+    is a:Sequence do (
+	if length(a) == 2 then (
+	    when a.0
+	    is o:HashTable do (
+		if o.Mutable then WrongArgImmutableHashTable(1)
+		else scanpairs(a.1, o))
+	    else scan(pairs(a.0), a.1))
+	else WrongNumArgs(2))
+    else WrongNumArgs(2));
+setupfun("scanPairs", scanPairs);
+
 nextPrime(e:Expr):Expr := (
      when e
      is x:ZZcell do toExpr(nextPrime(x.v - oneZZ))

M2/Macaulay2/d/actors4.d

@@ -200,6 +200,8 @@ select(e:Expr):Expr := (
      else WrongNumArgs(2,5));
 setupfun("select", select).Protected = false; -- will be overloaded in m2/lists.m2 and m2/regex.m2
 
+-- # typical value: selectPairs, HashTable, Function, HashTable
+-- # typical value: selectPairs, ZZ, HashTable, Function, HashTable
 selectPairs(nval:int, obj:HashTable, f:Expr):Expr := (
     u := newHashTable(obj.Class,obj.parent);
     u.beingInitialized = true;
@@ -228,18 +230,18 @@ selectPairs(nval:int, obj:HashTable, f:Expr):Expr := (
 		    "expected predicate to yield true or false"));
 	    p = p.next));
     Expr(sethash(u,obj.Mutable)));
+-- TODO: support iterators
 selectPairs(e:Expr):Expr := (
     when e
     is a:Sequence do (
-	-- # typical value: selectPairs, HashTable, Function, HashTable
 	if length(a) == 2 then (
 	    when a.0
 	    is obj:HashTable do (
 		if obj.Mutable
-		then WrongArg(1, "an immutable hash table")
+		then WrongArgImmutableHashTable(1)
 		else selectPairs(obj.numEntries, obj, a.1))
-	    else WrongArgHashTable(1))
-	-- # typical value: selectPairs, ZZ, HashTable, Function, HashTable
+	    -- # typical value: selectPairs, BasicList, Function, List
+	    else select(pairs(a.0), a.1))
 	else if length(a) == 3 then (
 	    when a.0
 	    is n:ZZcell do (
@@ -248,9 +250,10 @@ selectPairs(e:Expr):Expr := (
 		    when a.1 is obj:HashTable
 		    do (
 			if obj.Mutable
-			then WrongArg(2, "an immutable hash table")
+			then WrongArgImmutableHashTable(2)
 			else selectPairs(toInt(n), obj, a.2))
-		    else WrongArgHashTable(2)))
+		    -- # typical value: selectPairs, ZZ, BasicList, Function, List
+		    else select(a.0, pairs(a.1), a.2, nullE, nullE)))
 	    else WrongArgZZ(1))
 	else WrongNumArgs(2, 3))
     else WrongNumArgs(2, 3));
@@ -298,7 +301,7 @@ any(f:Expr,e:Expr):Expr := (
      is b:List do Expr(any(f,b.v))
      is i:ZZcell do if isInt(i) then Expr(any(f,toInt(i))) else WrongArgSmallInteger(1)
      is c:HashTable do
-     if c.Mutable then WrongArg(1,"an immutable hash table") else
+     if c.Mutable then WrongArgImmutableHashTable(1) else
      Expr(any(f,c))
      else WrongArg("a list or a hash table"));
 any(f:Expr,a:Sequence,b:Sequence):Expr := (

M2/Macaulay2/d/evaluate.d

@@ -28,6 +28,7 @@ export iteratorS := setupvar("iterator", nullE);
 export nextS := setupvar("next", nullE);
 export applyIteratorS := setupvar("applyIterator", nullE);
 export joinIteratorsS := setupvar("joinIterators", nullE);
+export pairsIteratorS := setupvar("pairsIterator", nullE);
 
 eval(c:Code):Expr;
 applyEE(f:Expr,e:Expr):Expr;
@@ -1709,7 +1710,7 @@ setup(LeftArrowS,assigntofun);
 idfun(e:Expr):Expr := e;
 setupfun("identity",idfun);
 -- # typical value: scanPairs, HashTable, Function, Nothing
-scanpairs(f:Expr,obj:HashTable):Expr := (	-- obj is not Mutable
+export scanpairs(f:Expr,obj:HashTable):Expr := (	-- obj is not Mutable
      foreach bucket in obj.table do (
 	  p := bucket;
 	  while true do (
@@ -1719,22 +1720,10 @@ scanpairs(f:Expr,obj:HashTable):Expr := (	-- obj is not Mutable
 	       p = p.next;
 	       ));
      nullE);
-scanpairsfun(e:Expr):Expr := (
-     when      e is a:Sequence do
-     if        length(a) == 2
-     then when a.0 is o:HashTable 
-     do
-     if	       o.Mutable
-     then      WrongArg("an immutable hash table")
-     else      scanpairs(a.1,o)
-     else      WrongArgHashTable(1)
-     else      WrongNumArgs(2)
-     else      WrongNumArgs(2));
-setupfun("scanPairs",scanpairsfun);
 
 mpre():Expr := buildErrorPacket("applyPairs: expected function to return null, a sequence of length 2, or an option x=>y");
 -- # typical value: applyPairs, HashTable, Function, HashTable
-mappairs(f:Expr,o:HashTable):Expr := (	-- o is not Mutable
+export mappairs(f:Expr,o:HashTable):Expr := (	-- o is not Mutable
      x := newHashTable(o.Class,o.parent);
      x.beingInitialized = true;
      foreach bucket in o.table do (
@@ -1762,18 +1751,6 @@ mappairs(f:Expr,o:HashTable):Expr := (	-- o is not Mutable
 	       p = p.next;
 	       ));
      Expr(sethash(x,o.Mutable)));
-mappairsfun(e:Expr):Expr := (
-     when      e is a:Sequence do
-     if        length(a) == 2
-     then when a.0 is o:HashTable 
-     do
-     if        o.Mutable 
-     then      WrongArg("an immutable hash table")
-     else      mappairs(a.1,o)
-     else      WrongArgHashTable(1)
-     else      WrongNumArgs(2)
-     else      WrongNumArgs(2));
-setupfun("applyPairs",mappairsfun);
 
 -- # typical value: applyKeys, HashTable, Function, HashTable
 export mapkeys(f:Expr,o:HashTable):Expr := (	-- o is not Mutable
@@ -1824,7 +1801,7 @@ mapkeysfun(e:Expr):Expr := (
      then when a.0 is o:HashTable 
      do        
      if        o.Mutable
-     then      WrongArg("an immutable hash table")
+     then      WrongArgImmutableHashTable()
      else      if length(a) == 2 then mapkeys(a.1,o) else mapkeysmerge(a.1,o,a.2)
      else      WrongArgHashTable(1)
      else      WrongNumArgs(2,3)
@@ -1864,7 +1841,7 @@ mapvaluesfun(e:Expr):Expr := (
      then when a.0 is o:HashTable 
      do        
      if        o.Mutable
-     then      WrongArg("an immutable hash table")
+     then      WrongArgImmutableHashTable()
      else      mapvalues(a.1,o)
      else      WrongArgHashTable(1)
      else      WrongNumArgs(2)
@@ -2066,18 +2043,18 @@ combine(e:Expr):Expr := (
      is v:Sequence do
      if length(v) == 5 then (
         when v.0 is x:HashTable do
-        if x.Mutable then WrongArg(1,"an immutable hash table") else
+        if x.Mutable then WrongArgImmutableHashTable(1) else
         when v.1 is y:HashTable do
-        if y.Mutable then WrongArg(2,"an immutable hash table") else
+        if y.Mutable then WrongArgImmutableHashTable(2) else
         combine(v.2,v.3,v.4,x,y)
         else WrongArgHashTable(2)
         else WrongArgHashTable(1)
      )
      else if length(v) == 6 then (
         when v.0 is x:HashTable do
-        if x.Mutable then WrongArg(1,"an immutable hash table") else
+        if x.Mutable then WrongArgImmutableHashTable(1) else
         when v.1 is y:HashTable do
-        if y.Mutable then WrongArg(2,"an immutable hash table") else
+        if y.Mutable then WrongArgImmutableHashTable(2) else
         twistCombine(v.2,v.3,v.4,v.5,x,y)
         else WrongArgHashTable(2)
         else WrongArgHashTable(1)

M2/Macaulay2/d/expr.d

@@ -389,6 +389,8 @@ export WrongArgMatrix(n:int):Expr := WrongArg(n,"a raw matrix");
 export WrongArgMatrix():Expr := WrongArg("a raw matrix");
 export WrongArgHashTable():Expr := WrongArg("a hash table");
 export WrongArgHashTable(n:int):Expr := WrongArg(n, "a hash table");
+export WrongArgImmutableHashTable():Expr := WrongArg("an immutable hash table");
+export WrongArgImmutableHashTable(n:int):Expr := WrongArg(n, "an immutable hash table");
 export ArgChanged(name:string,n:int):Expr := (
      buildErrorPacket(quoteit(name) + " expected argument " + tostring(n)
 	  + " not to change its type during execution"));

M2/Macaulay2/d/hashtables.dd

@@ -255,17 +255,19 @@ export toHashTable(v:Sequence):Expr := (
      Expr(sethash(o,false)));
 toHashTable(e:Expr):Expr := (
      when e
+     -- # typical value: hashTable, BasicList, HashTable
      is w:List do toHashTable(w.v)
      is s:Sequence do (
-	  if length(s) != 2 then return WrongNumArgs(1,2);
-	  when s.0
-	  is FunctionClosure do nothing
-	  is CompiledFunction do nothing
-	  is CompiledFunctionClosure do nothing
-	  else return WrongArg(1,"a function");
-	  when s.1 is w:List do toHashTableWithCollisionHandler(w.v,s.0)
-	  else WrongArg(2,"a list"))
-     else WrongArg("a list"));
+	  if length(s) == 2 then (
+	      if isFunction(s.0) then (
+		  when s.1
+		  -- # typical value: hashTable, Function, BasicList, HashTable
+		  is w:Sequence do toHashTableWithCollisionHandler(w, s.0)
+		  is w:List do toHashTableWithCollisionHandler(w.v, s.0)
+		  else WrongArg(2, "a list or sequence"))
+	      else toHashTable(s))
+	  else toHashTable(s))
+     else WrongArg("a list or sequence"));
 setupfun("hashTable",toHashTable);
 
 copy(table:array(KeyValuePair)):array(KeyValuePair) := (

M2/Macaulay2/d/pthread.d

@@ -42,14 +42,6 @@ startup(tb:TaskCellBody):null := (
      compilerBarrier();
      null());
 
-isFunction(e:Expr):bool := (
-     when e
-     is CompiledFunction do true
-     is CompiledFunctionClosure do true
-     is FunctionClosure do true
-     is s:SpecialExpr do isFunction(s.e)
-     else false);
-
 taskDone(tb:TaskCellBody):bool := tb.resultRetrieved || taskDone(tb.task);
 
 cancelTask(tb:TaskCellBody):Expr := (

M2/Macaulay2/d/util.d

@@ -187,6 +187,14 @@ export getSequenceOfMutableMatrices(e:Expr) : RawMutableMatrixArray := (
      is a:RawMutableMatrixCell do RawMutableMatrixArray(a.p)
      else RawMutableMatrixArray());
 
+export isFunction(e:Expr):bool := (
+     when e
+     is CompiledFunction do true
+     is CompiledFunctionClosure do true
+     is FunctionClosure do true
+     is s:SpecialExpr do isFunction(s.e)
+     else false);
+
 -----------------------------------------------------------------------------
 -- helper routines for checking and converting return values
 

M2/Macaulay2/m2/iterators.m2

@@ -65,3 +65,11 @@ joinIterators = a -> (
 		r))))
 
 Iterator | Iterator := (x, y) -> joinIterators(x, y)
+
+pairsIterator = x -> Iterator (
+    iter := iterator x;
+    i := 0;
+    () -> (
+	y := next iter;
+	if y === StopIteration then StopIteration
+	else (i, (i += 1; y))))

M2/Macaulay2/m2/typicalvalues.m2

@@ -51,8 +51,6 @@ take(BasicList,ZZ) := take(BasicList,List) := BasicList => take
 take(Thing,ZZ) := take(Thing,List) := List => take
 
 isMutable(Thing) := Boolean => isMutable
-hashTable List := HashTable => hashTable
-hashTable(Function,List) := HashTable => hashTable
 remove(MutableList,ZZ) := Nothing => remove
 remove(Database,String) := Nothing => remove
 remove(HashTable,Thing) := Nothing => remove