[renamed-map-to-dict
strick**20120206092623
 Ignore-this: b8c6c3abccccf111cc8d859d3c85d486
] hunk ./Cls.java 158
-                "Return a Map of the method names defined on the class.") {
+                "Return a Dict of the method names defined on the class.") {
hunk ./Cls.java 162
-                Map z = new Map(terp);
+                Dict z = new Dict(terp);
hunk ./Cls.java 164
-                    z.map.put(terp.newStr(s), self.meths.get(s));
+                    z.dict.put(terp.newStr(s), self.meths.get(s));
hunk ./Cls.java 253
-                return terp.newMap(arr);
+                return terp.newDict(arr);
hunk ./Cls.java 290
-            return fmt("<%s %s> *** Implemented in Java ***", onCls, name);
+            return fmt("\"<%s %s> Built-In Method\"", onCls, name);
hunk ./ExprTest.java 93
-    public void testMap() {
-        Expr.Top top = Parser.parseMethod(usrCls, "temp", "a@ Map new . a at: 'foo' p: 333 . a at: 'foo' ");
+    public void testDict() {
+        Expr.Top top = Parser.parseMethod(usrCls, "temp", "a@ Dict new . a at: 'foo' p: 333 . a at: 'foo' ");
hunk ./ExprTest.java 165
-    public void testBlkToMap() {
-        Expr.Top top = Parser.parseMethod(usrCls, "temp", " [ 1 pl/ 1 . 2 pl/ 2 ; 3 pl/ 3 . 4 pl/ 4 ; ] map at: 2 ");
+    public void testBlkToDict() {
+        Expr.Top top = Parser.parseMethod(usrCls, "temp", " [ 1 pl/ 1 . 2 pl/ 2 ; 3 pl/ 3 . 4 pl/ 4 ; ] dict at: 2 ");
hunk ./Pro.java 70
-    Map asMap() {
+    Dict asDict() {
hunk ./Pro.java 469
-            terp.tBlk.addMethod(new JavMeth(terp.tBlk, "map", "m", "Evalute members of the block to make a Map.  "
+            terp.tBlk.addMethod(new JavMeth(terp.tBlk, "dict", "d", "Evalute members of the block to make a Dict.  "
hunk ./Pro.java 480
-                    return terp.newMap(arr);
+                    return terp.newDict(arr);
hunk ./Pro.java 918
-            StringBuffer sb = new StringBuffer("[ ");
+            StringBuffer sb = new StringBuffer("Vec{");
hunk ./Pro.java 920
-                sb.append(vec.get(i) == null ? "<***NULL***>" : vec.get(i).toString());
+                sb.append(vec.get(i) == null ? " nil\"NULL\" " : vec.get(i).toString());
hunk ./Pro.java 923
-            sb.append("] vec ");
+            sb.append("} ");
hunk ./Pro.java 1038
-    public final static class Map extends Obj {
-        HashMap<Pro, Pro> map;
+    public final static class Dict extends Obj {
+        HashMap<Pro, Pro> dict;
hunk ./Pro.java 1041
-        Map(Terp t) {
-            super(t.tMap);
-            this.map = new HashMap<Pro, Pro>();
+        Dict(Terp t) {
+            super(t.tDict);
+            this.dict = new HashMap<Pro, Pro>();
hunk ./Pro.java 1045
-        Map asMap() {
+        Dict asDict() {
hunk ./Pro.java 1050
-            StringBuffer sb = new StringBuffer("Map{");
+            StringBuffer sb = new StringBuffer("Dict{");
hunk ./Pro.java 1061
-            if (o instanceof Map) {
-                Map that = (Map) o;
-                int sz = this.map.size();
-                if (sz == that.map.size()) {
+            if (o instanceof Dict) {
+                Dict that = (Dict) o;
+                int sz = this.dict.size();
+                if (sz == that.dict.size()) {
hunk ./Pro.java 1087
-            v.visitMap(this);
+            v.visitDict(this);
hunk ./Pro.java 1090
-            Assoc[] z = new Assoc[map.size()];
+            Assoc[] z = new Assoc[dict.size()];
hunk ./Pro.java 1092
-            for (Pro key : map.keySet()) {
-                z[i] = new Assoc(key, map.get(key));
+            for (Pro key : dict.keySet()) {
+                z[i] = new Assoc(key, dict.get(key));
hunk ./Pro.java 1100
-        static void addBuiltinMethodsForMap(final Terp terp) {
-            terp.tMap.addMethod(new JavMeth(terp.tMap, "len", "", "Number of entries in the Map.") {
+        static void addBuiltinMethodsForDict(final Terp terp) {
+            terp.tDict.addMethod(new JavMeth(terp.tDict, "len", "", "Number of entries in the Dict.") {
hunk ./Pro.java 1103
-                    return new Num(terp, r.asMap().map.size());
+                    return new Num(terp, r.asDict().dict.size());
hunk ./Pro.java 1106
-            terp.tMap.addMethod(new JavMeth(terp.tMap, "dir", "", "Number of entries in the Map.") {
+            terp.tDict.addMethod(new JavMeth(terp.tDict, "dir", "", "Number of entries in the Dict.") {
hunk ./Pro.java 1109
-                    for (Assoc aa : r.asMap().sortedAssocs()) {
+                    for (Assoc aa : r.asDict().sortedAssocs()) {
hunk ./Pro.java 1115
-            terp.tMap.addMethod(new JavMeth(terp.tMap, "at:", "",
+            terp.tDict.addMethod(new JavMeth(terp.tDict, "at:", "",
hunk ./Pro.java 1118
-                    Map self = r.asMap();
-                    Pro z = self.map.get(args[0]);
+                    Dict self = r.asDict();
+                    Pro z = self.dict.get(args[0]);
hunk ./Pro.java 1126
-            terp.tMap.addMethod(new JavMeth(terp.tMap, "at:put:", "at:p:", "") {
+            terp.tDict.addMethod(new JavMeth(terp.tDict, "at:put:", "at:p:", "") {
hunk ./Pro.java 1128
-                    Map self = r.asMap();
-                    self.map.put(args[0], args[1]);
+                    Dict self = r.asDict();
+                    self.dict.put(args[0], args[1]);
hunk ./Pro.java 1133
-            terp.tMapCls.addMethod(new JavMeth(terp.tMapCls, "new", "", "Create a new empty Map object.") {
+            terp.tDictCls.addMethod(new JavMeth(terp.tDictCls, "new", "", "Create a new empty Dict object.") {
hunk ./Pro.java 1135
-                    return new Map(terp);
+                    return new Dict(terp);
hunk ./Talk.java 18
-import net.yak.stalk.Pro.Map;
+import net.yak.stalk.Pro.Dict;
hunk ./Talk.java 229
-        Cls tMap;
-        Cls tMapCls;
+        Cls tDict;
+        Cls tDictCls;
hunk ./Talk.java 306
-            this.tMapCls = new Cls(tMetaclsCls, this, "MapCls", tObjCls);
-            this.tMap = new Cls(tMapCls, this, "Map", tObj);
+            this.tDictCls = new Cls(tMetaclsCls, this, "DictCls", tObjCls);
+            this.tDict = new Cls(tDictCls, this, "Dict", tObj);
hunk ./Talk.java 324
-            Map.addBuiltinMethodsForMap(this);
+            Dict.addBuiltinMethodsForDict(this);
hunk ./Talk.java 398
-        Map newMap(Pro[] kvArray) {
-            Map z = new Map(this);
+        Dict newDict(Pro[] kvArray) {
+            Dict z = new Dict(this);
hunk ./Talk.java 401
-                z.map.put(kvArray[i], kvArray[i + 1]);
+                z.dict.put(kvArray[i], kvArray[i + 1]);
hunk ./Talk.java 426
-        Map handleUrl(String url, HashMap<String, String> query) {
+        Dict handleUrl(String url, HashMap<String, String> query) {
hunk ./Talk.java 436
-            Map qMap = newMap(kvArray);
+            Dict qDict = newDict(kvArray);
hunk ./Talk.java 447
-            Map result = null;
+            Dict result = null;
hunk ./Talk.java 454
-                Pro result_pro = self.asObj().eval(fmt("self handle: %s quer: %s", newStr(url), qMap));
-                result = result_pro.asMap();
+                Pro result_pro = self.asObj().eval(fmt("self handle: %s quer: %s", newStr(url), qDict));
+                result = result_pro.asDict();
hunk ./Talk.java 457
-                    toss("Sending <handle:> to instance of <%s> did not return a Map: <%s>", appName, result_pro);
+                    toss("Sending <handle:> to instance of <%s> did not return a Dict: <%s>", appName, result_pro);
hunk ./Talk.java 467
-                Pro[] map_arr = new Pro[] { newStr("type"), newStr("text"), newStr("title"), newStr(ex.toString()),
+                Pro[] dict_arr = new Pro[] { newStr("type"), newStr("text"), newStr("title"), newStr(ex.toString()),
hunk ./Talk.java 469
-                result = newMap(map_arr);
+                result = newDict(dict_arr);
hunk ./Talk.java 581
-        void visitMap(Map a) {
+        void visitDict(Dict a) {
hunk ./WebServer.java 19
-import net.yak.stalk.Pro.Map;
+import net.yak.stalk.Pro.Dict;
hunk ./WebServer.java 146
-        void visitMap(Map a) {
+        void visitDict(Dict a) {
hunk ./WebServer.java 192
-    public class EditMapRenderer {
-        Map map;
+    public class EditDictRenderer {
+        Dict dict;
hunk ./WebServer.java 195
-        public EditMapRenderer(Map map) {
-            this.map = map;
+        public EditDictRenderer(Dict dict) {
+            this.dict = dict;
hunk ./WebServer.java 199
-            String text = maybeString(map.map.get(VALUE), "ERROR: Missing value in map.");
-            String action = maybeString(map.map.get(ACTION), "ERROR: Missing action in map.");
+            String text = maybeString(dict.dict.get(VALUE), "ERROR: Missing value in dict.");
+            String action = maybeString(dict.dict.get(ACTION), "ERROR: Missing action in dict.");
hunk ./WebServer.java 202
-            String title = maybeString(map.map.get(TITLE), "Untitled");
+            String title = maybeString(dict.dict.get(TITLE), "Untitled");
hunk ./WebServer.java 210
-            if (map.map.containsKey(FIELD1)) {
-                String fname = maybeString(map.map.get(FIELD1), "?");
-                String fvalue = maybeString(map.map.get(VALUE1), "?");
+            if (dict.dict.containsKey(FIELD1)) {
+                String fname = maybeString(dict.dict.get(FIELD1), "?");
+                String fvalue = maybeString(dict.dict.get(VALUE1), "?");
hunk ./WebServer.java 216
-            if (map.map.containsKey(FIELD2)) {
-                String fname = maybeString(map.map.get(FIELD2), "?");
-                String fvalue = maybeString(map.map.get(VALUE2), "?");
+            if (dict.dict.containsKey(FIELD2)) {
+                String fname = maybeString(dict.dict.get(FIELD2), "?");
+                String fvalue = maybeString(dict.dict.get(VALUE2), "?");
hunk ./WebServer.java 228
-            Ht.tag(page, "p", null, map.toString());
+            Ht.tag(page, "p", null, dict.toString());
hunk ./WebServer.java 233
-    public class TextMapRenderer {
-        Map map;
+    public class TextDictRenderer {
+        Dict dict;
hunk ./WebServer.java 236
-        public TextMapRenderer(Map map) {
-            this.map = map;
+        public TextDictRenderer(Dict dict) {
+            this.dict = dict;
hunk ./WebServer.java 240
-            String text = maybeString(map.map.get(VALUE), "ERROR: Missing value in map.");
+            String text = maybeString(dict.dict.get(VALUE), "ERROR: Missing value in dict.");
hunk ./WebServer.java 242
-            String title = maybeString(map.map.get(TITLE), "Untitled");
+            String title = maybeString(dict.dict.get(TITLE), "Untitled");
hunk ./WebServer.java 246
-            Ht.tag(page, "p", null, map.toString());
+            Ht.tag(page, "p", null, dict.toString());
hunk ./WebServer.java 251
-    public class ListMapRenderer {
-        Map map;
+    public class ListDictRenderer {
+        Dict dict;
hunk ./WebServer.java 254
-        public ListMapRenderer(Map map) {
-            this.map = map;
+        public ListDictRenderer(Dict dict) {
+            this.dict = dict;
hunk ./WebServer.java 259
-            Vec list = (Vec) map.map.get(VALUE);
+            Vec list = (Vec) dict.dict.get(VALUE);
hunk ./WebServer.java 271
-            String title = maybeString(map.map.get(TITLE), "Untitled");
+            String title = maybeString(dict.dict.get(TITLE), "Untitled");
hunk ./WebServer.java 275
-            Ht.tag(page, "p", null, map.toString());
+            Ht.tag(page, "p", null, dict.toString());
hunk ./WebServer.java 280
-    public class MapRenderer {
-        Map  map;
+    public class DictRenderer {
+        Dict  dict;
hunk ./WebServer.java 284
-        public MapRenderer(Map map) {
-            this.map = map;
-            this.terp = map.terp();
+        public DictRenderer(Dict dict) {
+            this.dict = dict;
+            this.terp = dict.terp();
hunk ./WebServer.java 290
-                Str type = map.map.get(TYPE).asStr();
+                Str type = dict.dict.get(TYPE).asStr();
hunk ./WebServer.java 292
-                    return new ListMapRenderer(map).toHt();
+                    return new ListDictRenderer(dict).toHt();
hunk ./WebServer.java 295
-                    return new TextMapRenderer(map).toHt();
+                    return new TextDictRenderer(dict).toHt();
hunk ./WebServer.java 298
-                    return new EditMapRenderer(map).toHt();
+                    return new EditDictRenderer(dict).toHt();
hunk ./WebServer.java 313
-                Ht.tag(z, "p", null, map.toString());
+                Ht.tag(z, "p", null, dict.toString());
hunk ./WebServer.java 319
-            vis.visitMap(map);
-            vis.ht.append(map.toString());
+            vis.visitDict(dict);
+            vis.ht.append(dict.toString());
hunk ./WebServer.java 353
-                    Map map = terp.handleUrl(path, query);
-                    response = new MapRenderer(map).toHt().toString();
+                    Dict dict = terp.handleUrl(path, query);
+                    response = new DictRenderer(dict).toHt().toString();
hunk ./init.txt 11
-      m= Map new; m at: 10 put: 100; m at: 10 pl:: 42
+      m= Dict new; m at: 10 put: 100; m at: 10 pl:: 42
hunk ./init.txt 13
-      m= Map new; m at:: 4 pl: 6 put:: 10 ti: 10; m at: 10 pl:: 42
+      m= Dict new; m at:: 4 pl: 6 put:: 10 ti: 10; m at: 10 pl:: 42
hunk ./init.txt 109
-  Map new  at: 'type' put: 'list'
+  Dict new  at: 'type' put: 'list'
hunk ./init.txt 122
-  ww= a split: '~' .  "It's a regexp."
+  ww= a split: '.' .  "It's a regexp."
hunk ./init.txt 145
-    z= Map new  at: 'type' put: 'list'
+    z= Dict new  at: 'type' put: 'list'
hunk ./init.txt 160
-    d= co cls methd .
+    d= co cls methDefs .
hunk ./init.txt 165
-    d= co methd .
+    d= co methDefs .
hunk ./init.txt 167
-      v ap: ( ( '|link|/EditMethod.' ap: cn , ap: '~' , ap: x , ap: '|' , ap: x ) tu: ( d at: x , str ) ) .
+      v ap: ( ( '|link|/EditMethod.' ap: cn , ap: '.' , ap: x , ap: '|' , ap: x ) tu: ( d at: x , str ) ) .
hunk ./init.txt 170
-    z= Map new  at: 'type' put: 'list'
+    z= Dict new  at: 'type' put: 'list'
hunk ./init.txt 181
-  ww= a split: '~' .
+  ww= a split: '.' .
hunk ./init.txt 191
-  mo= co methd at: mn .  "method object"
+  mo= co methDefs at: mn .  "method object"
hunk ./init.txt 193
-  z= Map new  at: 'type' p: 'edit'
+  z= Dict new  at: 'type' p: 'edit'