py, builtin, vm: make str() and repr() and implement some __str__ and __repr__

ncw · ncw · commit 3f14f3df5de5 · 2015-06-14T12:17:27.000+01:00
* builtin: implement repr
  * buitin and py/str: make str() work
  * py: str, int, bigint: __str__ and __repr__ for
  * py: Internal Str, Repr methods
  * vm: Make REPL use Repr for printing
diff --git a/builtin/builtin.go b/builtin/builtin.go
@@ -52,7 +52,7 @@ func init() {
 		py.MustNewMethod("ord", builtin_ord, 0, ord_doc),
 		py.MustNewMethod("pow", builtin_pow, 0, pow_doc),
 		py.MustNewMethod("print", builtin_print, 0, print_doc),
-		// py.MustNewMethod("repr", builtin_repr, 0, repr_doc),
+		py.MustNewMethod("repr", builtin_repr, 0, repr_doc),
 		py.MustNewMethod("round", builtin_round, 0, round_doc),
 		py.MustNewMethod("setattr", builtin_setattr, 0, setattr_doc),
 		// py.MustNewMethod("sorted", builtin_sorted, 0, sorted_doc),
@@ -194,6 +194,15 @@ func builtin_print(self py.Object, args py.Tuple, kwargs py.StringDict) (py.Obje
 	return py.None, nil
 }
 
+const repr_doc = `repr(object) -> string
+
+Return the canonical string representation of the object.
+For most object types, eval(repr(object)) == object.`
+
+func builtin_repr(self py.Object, obj py.Object) (py.Object, error) {
+	return py.Repr(obj)
+}
+
 const pow_doc = `pow(x, y[, z]) -> number
 
 With two arguments, equivalent to x**y.  With three arguments,
diff --git a/builtin/tests/builtin.py b/builtin/tests/builtin.py
@@ -111,7 +111,11 @@ def gen2():
 
 doc="pow"
 assert pow(2, 10) == 1024
-# FIXME assert pow(2, 10, 17) == 4
+assert pow(2, 10, 17) == 4
+
+doc="repr"
+assert repr(5) == "5"
+assert repr("hello") == "'hello'"
 
 doc="print"
 # FIXME - need io redirection to test
diff --git a/notes.txt b/notes.txt
@@ -4,29 +4,110 @@ Code Quality
   * errchk ./...
   * go vet ./...
 
-Limitations
-===========
+IDEA replace all .(cast) with CheckExactString or whatever python calls it...
+
+Then can use CheckString later...
+
+Limitations & Missing parts
+===========================
   * string keys only in dictionaries
     * intermediate fix - stop it panicing!
   * line numbers missing in SyntaxErrors
   * \N{...} escapes not implemented
   * Interactive interpreter does single lines only
   * compile(..., "single") not working
   * lots of builtins still to implement
+  * FIXME eq && ne should throw an error for a type which doesn' have eq implemented
+  * repr/str
+  * subclassing built in types - how? Need to make sure we have called the appropriate method everywhere rather than just .(String)
+  * FIXME how do mapping types work?
 
-Todo
-====
+Type ideas
+==========
 
-FIXME move the whole of Vm into Frame! Perhaps decode the extended args inline.
+  * Embed a zero sized struct with default implementations of all the methods to avoid interface bloat
+    * would have a pointer to the start of the object so could do comparisons
+    * however don't know anything about the object - can't call Type() for instance
+    * except for String/Int/Bool/Tuple/Float/Bytes and possibly some others...
+    * can embed this default interface whether we do fat interfaces or not...
+    * can have heirachies of embedding
 
-Speedup
   * Make Object a fat interface so it defines all the M__method__ or at least all the common ones
-    * Embed a zero sized struct with default implementations of all the methods to avoid interface bloat
-    * except for String/Int/Bool/Tuple/Float/Bytes and possibly some others...
+    * would make the M__call__ quicker than needing a type assertion
   * Or Make the methods be pointers in *Type more like python
-    * Function pointers would have to be func(a Object) (Object, error) which would mean a type assertion :-(
+    * Closer to the way python does it and would be faster than type assertion
+    * Function pointers would have to be func(a Object) (Object,
+      error) which would mean a type assertion which we are trying to
+      avoid :-(
     * An interface is the go way of doing this
 
+What methods are a default implementation useful for?
+  __eq__
+  __ne__
+  __repr__
+  __str__
+  __lt__ __add__ etc - could return NotImplemented
+  __hash__ - based on pointer?
+
+Minimum set of methods / attributes (eg on None)
+
+Attributes
+
+__class__
+__doc__
+
+Methods
+
+__bool__
+__delattr__
+__dir__
+__format__
+__getattribute__
+__hash__
+__init__
+__new__
+__reduce__     - pickle protocol - missing!
+__reduce_ex__  - pickle protocol - missing!
+__repr__
+__setattr__
+__sizeof__     - missing from py.go
+__str__
+__subclasshook__ - missing from py.go
+
+Comparison
+
+__eq__
+__ge__
+__gt__
+__le__
+__lt__
+__ne__
+
+
+genpy
+=====
+
+Code automation to help with the boilerplate of making types and modules
+
+  * For modules
+    * instrospect code
+    * make module table
+    * fill in arguments 
+    * fill in docstr (from comments)
+    * Module methods should be exportable with capital letter
+
+  * For a type
+    * create getters/setters from struct comments
+    * create default implementations 
+    * independent of use 0 sized embedded struct idea
+
+
+Todo
+====
+
+FIXME move the whole of Vm into Frame! Perhaps decode the extended args inline.
+
+Speedup
 
   * Getting rid of panic/defer error handling
 
@@ -37,7 +118,6 @@ After 3278 pystone/s
 After compile debug out with a constant 9293 pystones/s + 180%
 Keep locals 9789 local 5% improvement
 
-
 Still to do
   * think about exception handling - do nested tracebacks work?
     * write a test for it!
@@ -57,12 +137,6 @@ CAN now inline the do_XXX functions into the EvalFrame which will probably speed
     * "select" - no idea how to implement!
     * "mutex"
 
-  * Write gengpy tool to
-    * instrospect code
-    * fill in module table
-    * fill in arguments 
-    * fill in docstr (from comments)
-
 FIXME need to be able to tell classes an instances apart!
 
 Put C modules in sub directory
@@ -122,15 +196,6 @@ Exceptions
 
 panic/recover only within single modules (like compiler/parser)
 
-Missing parts
-=============
-  * repr/str
-  * subclassing built in types
-  * integers > 64 bit
-    * make py.Int be a wrapper for int
-    * make it promote to py.BigInt
-  * StringDict vs Dict
-
 Polymorphism
 ============
 
diff --git a/py/bigint.go b/py/bigint.go
@@ -3,6 +3,7 @@
 package py
 
 import (
+	"fmt"
 	"math"
 	"math/big"
 )
@@ -16,6 +17,14 @@ func (o *BigInt) Type() *Type {
 	return BigIntType
 }
 
+func (a *BigInt) M__str__() (Object, error) {
+	return String(fmt.Sprintf("%d", (*big.Int)(a))), nil
+}
+
+func (a *BigInt) M__repr__() (Object, error) {
+	return a.M__str__()
+}
+
 // Some common BigInts
 var (
 	bigInt0   = (*BigInt)(big.NewInt(0))
diff --git a/py/dict.go b/py/dict.go
@@ -5,9 +5,20 @@
 
 package py
 
-var StringDictType = NewType("dict", "dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)")
+const dictDoc = `dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)`
 
-var DictType = NewType("dict", "dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)")
+var (
+	StringDictType = NewType("dict", dictDoc)
+	DictType       = NewType("dict", dictDoc)
+)
 
 // String to object dictionary
 //
diff --git a/py/float.go b/py/float.go
@@ -3,6 +3,7 @@
 package py
 
 import (
+	"fmt"
 	"math"
 	"math/big"
 	"strconv"
@@ -41,6 +42,14 @@ func FloatNew(metatype *Type, args Tuple, kwargs StringDict) (Object, error) {
 	return MakeFloat(xObj)
 }
 
+func (a Float) M__str__() (Object, error) {
+	return String(fmt.Sprintf("%g", a)), nil
+}
+
+func (a Float) M__repr__() (Object, error) {
+	return a.M__str__()
+}
+
 // FloatFromString turns a string into a Float
 func FloatFromString(str string) (Object, error) {
 	f, err := strconv.ParseFloat(str, 64)
diff --git a/py/int.go b/py/int.go
@@ -3,6 +3,7 @@
 package py
 
 import (
+	"fmt"
 	"math"
 	"math/big"
 	"strconv"
@@ -174,6 +175,14 @@ func (x Int) GoInt() (int, error) {
 	return int(r), nil
 }
 
+func (a Int) M__str__() (Object, error) {
+	return String(fmt.Sprintf("%d", a)), nil
+}
+
+func (a Int) M__repr__() (Object, error) {
+	return a.M__str__()
+}
+
 // Arithmetic
 
 // Errors
diff --git a/py/internal.go b/py/internal.go
@@ -4,6 +4,8 @@
 
 package py
 
+import "fmt"
+
 // AttributeName converts an Object to a string, raising a TypeError
 // if it wasn't a String
 func AttributeName(keyObj Object) (string, error) {
@@ -321,3 +323,55 @@ func DeleteAttr(self Object, keyObj Object) error {
 	}
 	return DeleteAttrString(self, key)
 }
+
+// Calls __str__ on the object
+//
+// If no method was found, returns ok as false
+func str(self Object) (res Object, ok bool, err error) {
+	if _, ok = self.(String); ok {
+		return self, true, nil
+	}
+	if I, ok := self.(I__str__); ok {
+		res, err = I.M__str__()
+		return res, true, err
+	} else if res, ok, err := TypeCall0(self, "__str__"); ok {
+		return res, true, err
+	}
+	return nil, false, nil
+}
+
+// Calls __str__ on the object
+func Str(self Object) (Object, error) {
+	res, ok, err := str(self)
+	if err != nil {
+		return nil, err
+	}
+	if !ok {
+		return nil, ExceptionNewf(TypeError, "object of type '%s' has no __str__()", self.Type().Name)
+	}
+	return res, err
+}
+
+// Calls __repr__ on the object or returns a sensible default
+func Repr(self Object) (Object, error) {
+	if I, ok := self.(I__repr__); ok {
+		return I.M__repr__()
+	} else if res, ok, err := TypeCall0(self, "__repr__"); ok {
+		return res, err
+	}
+	return String(fmt.Sprintf("<%s instance at %p>", self.Type().Name, self)), nil
+}
+
+// Returns object as a string
+//
+// Calls __str__ then __repr__ on the object then makes something up
+func AsString(self Object) (Object, error) {
+	res, ok, err := str(self)
+	if err != nil {
+		return nil, err
+	}
+	if ok {
+		return res, err
+	}
+	return Repr(self)
+}
diff --git a/py/string.go b/py/string.go
diff --git a/py/tests/int.py b/py/tests/int.py
diff --git a/py/tests/string.py b/py/tests/string.py
diff --git a/vm/eval.go b/vm/eval.go
