added strings and IObject

halgari · halgari · commit 54e95c3d1f90 · 2014-10-03T21:20:25.000-06:00
diff --git a/pixie/vm/code.py b/pixie/vm/code.py
@@ -222,6 +222,14 @@ def get_var_if_defined(ns, name):
 
 
 
+class DefaultProtocolFn(NativeFn):
+    def __init__(self, pfn):
+        self._pfn = pfn
+
+    def _invoke(self, args):
+        from pixie.vm.string import String
+        tp = args[0].type()._name
+        raise Exception("No override for " + tp + " on " + self._pfn._name + " in protocol " + self._pfn._protocol._name)
 
 
 class Protocol(object.Object):
@@ -232,6 +240,7 @@ def __init__(self, name):
         self._polyfns = {}
         self._satisfies = {}
 
+
     def add_method(self, pfn):
         self._polyfns[pfn] = pfn
 
@@ -251,17 +260,21 @@ def __init__(self, name, protocol):
         self._dict = {}
         self._rev = 0
         self._protocol = protocol
+        self._default_fn = DefaultProtocolFn(self)
         protocol.add_method(self)
 
     def extend(self, tp, fn):
         self._dict[tp] = fn
         self._rev += 1
         self._protocol.add_satisfies(tp)
 
+    def set_default_fn(self, fn):
+        self._default_fn = fn
+        self._rev += 1
+
     def _invoke(self, args):
         a = args[0].type()
-        fn = self._dict.get(a, None)
-        assert fn is not None, "No override for " + self._name + " for type " + a._name
+        fn = self._dict.get(a, self._default_fn)
         return fn.invoke(args)
 
 class DoublePolymorphicFn(BaseCode):
diff --git a/pixie/vm/keyword.py b/pixie/vm/keyword.py
@@ -8,6 +8,9 @@ class Keyword(Object):
     def __init__(self, name):
         self._name = name
 
+    def type(self):
+        return Keyword._type
+
 
 class KeywordCache(object):
     def __init__(self):
diff --git a/pixie/vm/numbers.py b/pixie/vm/numbers.py
@@ -66,3 +66,17 @@ def eq(a, b):
 
     raise Exception("Add error")
 
+
+def init():
+    import pixie.vm.protocols as proto
+    from pixie.vm.string import String
+
+    @extend(proto._str, Integer._type)
+    def _str(i):
+        return String(str(i.int_val()))
+
+    @extend(proto._repr, Integer._type)
+    def _repr(i):
+        return String(str(i.int_val()))
+
+
diff --git a/pixie/vm/object.py b/pixie/vm/object.py
@@ -5,7 +5,7 @@ class Object(object):
     """
 
     def type(self):
-        assert False;
+        assert False, str(self)
 
 class Type(Object):
 
diff --git a/pixie/vm/protocols.py b/pixie/vm/protocols.py
@@ -2,7 +2,7 @@
 from pixie.vm.code import BaseCode, PolymorphicFn, wrap_fn, as_var, defprotocol, extend
 from types import MethodType
 from pixie.vm.primitives import true, false, nil
-from pixie.vm.numbers import Integer, zero_int, _add
+import pixie.vm.numbers as numbers
 import rpython.rlib.jit as jit
 import rpython.rlib.rstacklet as rstacklet
 
@@ -16,6 +16,16 @@
 
 defprotocol("pixie.stdlib", "IPersistentCollection", ["-conj"])
 
+defprotocol("pixie.stdlib", "IObject", ["-hash", "-eq", "-str", "-repr"])
+
+def default_str(x):
+    from pixie.vm.string import String
+
+    return String("<inst " + x.type()._name + ">")
+
+_str.set_default_fn(wrap_fn(default_str))
+_repr.set_default_fn(wrap_fn(default_str))
+
 #_first = PolymorphicFn("-first")
 #_next = PolymorphicFn("-next")
 
@@ -51,7 +61,7 @@ def _seq(_):
 
 @extend(_count, nil._type)
 def _count(_):
-    return zero_int
+    return numbers.zero_int
 
 
 _count_driver = jit.JitDriver(name="pixie.stdlib.count",
@@ -63,7 +73,7 @@ def count(x):
     while True:
         _count_driver.jit_merge_point(tp=rt.type(x))
         if ICounted.satisfies(rt.type(x)):
-           return rt._add(Integer(acc), rt._count(x))
+           return rt._add(numbers.Integer(acc), rt._count(x))
         acc += 1
         x = rt.next(rt.seq(x))
 
@@ -81,5 +91,10 @@ def nth(a, b):
     return rt._nth(a, b)
 
 
+@as_var("str")
+def str(a):
+    return rt._str(a)
 
 import pixie.vm.rt as rt
+
+
diff --git a/pixie/vm/rt.py b/pixie/vm/rt.py
@@ -7,7 +7,8 @@ def init():
     if globals().has_key("__inited__"):
         return
 
-    import pixie.vm.numbers
+    import pixie.vm.numbers as numbers
+    numbers.init()
 
     from pixie.vm.code import _ns_registry, BaseCode, munge
 
diff --git a/pixie/vm/string.py b/pixie/vm/string.py
@@ -0,0 +1,21 @@
+import pixie.vm.rt as rt
+from pixie.vm.object import Object, Type
+from pixie.vm.code import extend, as_var
+import pixie.vm.protocols as proto
+
+class String(Object):
+    _type = Type("pixie.stdlib.String")
+
+    def type(self):
+        return String._type
+
+    def __init__(self, s):
+        self._str = s
+
+@extend(proto._str, String._type)
+def _str(x):
+    return x
+
+@extend(proto._repr, String._type)
+def _repr(self):
+    return "\"" + self._str + "\""
diff --git a/target.py b/target.py
@@ -43,10 +43,17 @@ def entry_point(foo=None):
     #                          ((create-stacklet foo) 0))
     # """), True)))
     from pixie.vm.keyword import keyword
+    import pixie.vm.rt as rt
+    from pixie.vm.string import String
+
+    rdr = PromptReader()
     while True:
-        val = interpret(compile(read(PromptReader(), True)))
+        val = interpret(compile(read(rdr, True)))
         if val is keyword("exit-repl"):
             break
+        val = rt.str(val)
+        assert isinstance(val, String), "str should always return a string"
+        print val._str
 
     return 0
 
