py: fix iterable object

Author: wetor

py/arithmetic.go

@@ -147,24 +147,6 @@ func MakeFloat(a Object) (Object, error) {
 	return nil, ExceptionNewf(TypeError, "unsupported operand type(s) for float: '%s'", a.Type().Name)
 }
 
-// Iter the python Object returning an Object
-//
-// Will raise TypeError if Iter can't be run on this object
-func Iter(a Object) (Object, error) {
-
-	if A, ok := a.(I__iter__); ok {
-		res, err := A.M__iter__()
-		if err != nil {
-			return nil, err
-		}
-		if res != NotImplemented {
-			return res, nil
-		}
-	}
-
-	return nil, ExceptionNewf(TypeError, "unsupported operand type(s) for iter: '%s'", a.Type().Name)
-}
-
 // Add two python objects together returning an Object
 //
 // Will raise TypeError if can't be add can't be run on these objects

py/dict.go

@@ -36,7 +36,7 @@ func init() {
 			return nil, err
 		}
 		sMap := self.(StringDict)
-		o := make([]Object, 0, len(sMap))
+		o := make(Tuple, 0, len(sMap))
 		for k, v := range sMap {
 			o = append(o, Tuple{String(k), v})
 		}
@@ -49,7 +49,7 @@ func init() {
 			return nil, err
 		}
 		sMap := self.(StringDict)
-		o := make([]Object, 0, len(sMap))
+		o := make(Tuple, 0, len(sMap))
 		for k := range sMap {
 			o = append(o, String(k))
 		}
@@ -62,7 +62,7 @@ func init() {
 			return nil, err
 		}
 		sMap := self.(StringDict)
-		o := make([]Object, 0, len(sMap))
+		o := make(Tuple, 0, len(sMap))
 		for _, v := range sMap {
 			o = append(o, v)
 		}
@@ -204,7 +204,7 @@ func (a StringDict) M__repr__() (Object, error) {
 
 // Returns a list of keys from the dict
 func (d StringDict) M__iter__() (Object, error) {
-	o := make([]Object, 0, len(d))
+	o := make(Tuple, 0, len(d))
 	for k := range d {
 		o = append(o, String(k))
 	}

py/exception.go

@@ -336,6 +336,8 @@ func ExceptionGivenMatches(err, exc Object) bool {
 func IsException(exception *Type, r interface{}) bool {
 	var t *Type
 	switch ex := r.(type) {
+	case ExceptionInfo:
+		t = ex.Type
 	case *Exception:
 		t = ex.Type()
 	case *Type:

py/gen.go

@@ -45,7 +45,6 @@ var data = Data{
 		{Name: "complex", Title: "MakeComplex", Operator: "complex", Unary: true, Conversion: "Complex"},
 		{Name: "int", Title: "MakeInt", Operator: "int", Unary: true, Conversion: "Int"},
 		{Name: "float", Title: "MakeFloat", Operator: "float", Unary: true, Conversion: "Float"},
-		{Name: "iter", Title: "Iter", Operator: "iter", Unary: true},
 	},
 	BinaryOps: Ops{
 		{Name: "add", Title: "Add", Operator: "+", Binary: true},

py/internal.go

@@ -430,3 +430,20 @@ func ReprAsString(self Object) (string, error) {
 	}
 	return string(str), nil
 }
+
+// Returns an iterator object
+//
+// Call __Iter__ Returns an iterator object
+//
+// If object is sequence object, create an iterator
+func Iter(self Object) (res Object, err error) {
+	if I, ok := self.(I__iter__); ok {
+		return I.M__iter__()
+	} else if res, ok, err = TypeCall0(self, "__iter__"); ok {
+		return res, err
+	}
+	if ObjectIsSequence(self) {
+		return NewIterator(self), nil
+	}
+	return nil, ExceptionNewf(TypeError, "'%s' object is not iterable", self.Type().Name)
+}

py/iterator.go

@@ -8,8 +8,8 @@ package py
 
 // A python Iterator object
 type Iterator struct {
-	Pos  int
-	Objs []Object
+	Pos int
+	Seq Object
 }
 
 var IteratorType = NewType("iterator", "iterator type")
@@ -20,10 +20,10 @@ func (o *Iterator) Type() *Type {
 }
 
 // Define a new iterator
-func NewIterator(Objs []Object) *Iterator {
+func NewIterator(Seq Object) *Iterator {
 	m := &Iterator{
-		Pos:  0,
-		Objs: Objs,
+		Pos: 0,
+		Seq: Seq,
 	}
 	return m
 }
@@ -33,13 +33,29 @@ func (it *Iterator) M__iter__() (Object, error) {
 }
 
 // Get next one from the iteration
-func (it *Iterator) M__next__() (Object, error) {
-	if it.Pos >= len(it.Objs) {
-		return nil, StopIteration
+func (it *Iterator) M__next__() (res Object, err error) {
+	if tuple, ok := it.Seq.(Tuple); ok {
+		if it.Pos >= len(tuple) {
+			return nil, StopIteration
+		}
+		res = tuple[it.Pos]
+		it.Pos++
+		return res, nil
+	}
+	index := Int(it.Pos)
+	if I, ok := it.Seq.(I__getitem__); ok {
+		res, err = I.M__getitem__(index)
+	} else if res, ok, err = TypeCall1(it.Seq, "__getitem__", index); !ok {
+		return nil, ExceptionNewf(TypeError, "'%s' object is not iterable", it.Type().Name)
+	}
+	if err != nil {
+		if IsException(IndexError, err) {
+			return nil, StopIteration
+		}
+		return nil, err
 	}
-	r := it.Objs[it.Pos]
 	it.Pos++
-	return r, nil
+	return res, nil
 }
 
 // Check interface is satisfied

py/list.go

@@ -186,7 +186,7 @@ func (l *List) M__bool__() (Object, error) {
 }
 
 func (l *List) M__iter__() (Object, error) {
-	return NewIterator(l.Items), nil
+	return NewIterator(Tuple(l.Items)), nil
 }
 
 func (l *List) M__getitem__(key Object) (Object, error) {
@@ -496,7 +496,11 @@ func SortInPlace(l *List, kwargs StringDict, funcName string) error {
 		reverse = False
 	}
 	// FIXME: requires the same bool-check like CPython (or better "|$Op" that doesn't panic on nil).
-	s := ptrSortable{&sortable{l, keyFunc, ObjectIsTrue(reverse), nil}}
+	ok, err := ObjectIsTrue(reverse)
+	if err != nil {
+		return err
+	}
+	s := ptrSortable{&sortable{l, keyFunc, ok, nil}}
 	sort.Stable(s)
 	return s.s.firstErr
 }

py/object.go

@@ -23,24 +23,53 @@ func ObjectRepr(o Object) Object {
 }
 
 // Return whether the object is True or not
-func ObjectIsTrue(o Object) bool {
-	if o == True {
-		return true
+func ObjectIsTrue(o Object) (cmp bool, err error) {
+	switch o {
+	case True:
+		return true, nil
+	case False:
+		return false, nil
+	case None:
+		return false, nil
 	}
-	if o == False {
-		return false
+
+	var res Object
+	switch t := o.(type) {
+	case I__bool__:
+		res, err = t.M__bool__()
+	case I__len__:
+		res, err = t.M__len__()
+	case *Type:
+		var ok bool
+		if res, ok, err = TypeCall0(o, "__bool__"); ok {
+			break
+		}
+		if res, ok, err = TypeCall0(o, "__len__"); ok {
+			break
+		}
+		_ = ok // pass static-check
+	}
+	if err != nil {
+		return false, err
 	}
 
-	if o == None {
-		return false
+	switch t := res.(type) {
+	case Bool:
+		return t == True, nil
+	case Int:
+		return t > 0, nil
 	}
+	return true, nil
+}
 
-	if I, ok := o.(I__bool__); ok {
-		cmp, err := I.M__bool__()
-		if err == nil && cmp == True {
+// Return whether the object is a sequence
+func ObjectIsSequence(o Object) bool {
+	switch t := o.(type) {
+	case I__getitem__:
+		return true
+	case *Type:
+		if t.GetAttrOrNil("__getitem__") != nil {
 			return true
-		} else if err == nil && cmp == False {
-			return false
 		}
 	}
 	return false

py/tests/iter.py

@@ -18,4 +18,16 @@ def f():
 words2 = list(iter(words1))
 for w1, w2 in zip(words1, words2):
     assert w1 == w2
+
+class SequenceClass:
+    def __init__(self, n):
+        self.n = n
+    def __getitem__(self, i):
+        if 0 <= i < self.n:
+            return i
+        else:
+            raise IndexError
+
+assert list(iter(SequenceClass(5))) == [0, 1, 2, 3, 4]
+
 doc="finished"

stdlib/builtin/builtin.go

@@ -292,7 +292,11 @@ func builtin_all(self, seq py.Object) (py.Object, error) {
 			}
 			return nil, err
 		}
-		if !py.ObjectIsTrue(item) {
+		ok, err := py.ObjectIsTrue(item)
+		if err != nil {
+			return nil, err
+		}
+		if !ok {
 			return py.False, nil
 		}
 	}
@@ -317,7 +321,11 @@ func builtin_any(self, seq py.Object) (py.Object, error) {
 			}
 			return nil, err
 		}
-		if py.ObjectIsTrue(item) {
+		ok, err := py.ObjectIsTrue(item)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
 			return py.True, nil
 		}
 	}