Implement list() factoring common parts out of tuple() into SequenceList, SequenceTuple and Iterate.

Author: ncw

py/internal.go

@@ -298,6 +298,23 @@ func Next(self Object) Object {
 	panic(ExceptionNewf(TypeError, "'%s' object is not iterable", self.Type().Name))
 }
 
+// Iterate the iterator until finished calling the function passed in on each object
+func Iterate(iterator Object, fn func(Object)) {
+	defer func() {
+		if r := recover(); r != nil {
+			if IsException(StopIteration, r) {
+				// StopIteration or subclass raised
+			} else {
+				panic(r)
+			}
+		}
+	}()
+	for {
+		item := Next(iterator)
+		fn(item)
+	}
+}
+
 // Call send for the python object
 func Send(self, value Object) Object {
 	if I, ok := self.(I_send); ok {

py/list.go

@@ -2,7 +2,7 @@
 
 package py
 
-var ListType = NewType("list", "list() -> new empty list\nlist(iterable) -> new list initialized from iterable's items")
+var ListType = ObjectType.NewType("list", "list() -> new empty list\nlist(iterable) -> new list initialized from iterable's items", ListNew, nil)
 
 // FIXME lists are mutable so this should probably be struct { Tuple } then can use the sub methods on Tuple
 type List struct {
@@ -14,6 +14,16 @@ func (o *List) Type() *Type {
 	return ListType
 }
 
+// ListNew
+func ListNew(metatype *Type, args Tuple, kwargs StringDict) (res Object) {
+	var iterable Object
+	UnpackTuple(args, kwargs, "list", 0, 1, &iterable)
+	if iterable != nil {
+		return SequenceList(iterable)
+	}
+	return NewList()
+}
+
 // Make a new empty list
 func NewList() *List {
 	return &List{}

py/sequence.go

@@ -4,24 +4,32 @@ package py
 
 // Converts a sequence object v into a Tuple
 func SequenceTuple(v Object) Tuple {
-	// FIXME need to support iterable objects etc!
 	switch x := v.(type) {
 	case Tuple:
 		return x
 	case *List:
 		return Tuple(x.Items).Copy()
+	default:
+		t := Tuple{}
+		Iterate(Iter(v), func(item Object) {
+			t = append(t, item)
+		})
+		return t
 	}
-	panic(ExceptionNewf(TypeError, "SequenceTuple not fully implemented, can't convert %s", v.Type().Name))
 }
 
 // Converts a sequence object v into a List
 func SequenceList(v Object) *List {
-	// FIXME need to support iterable objects etc!
 	switch x := v.(type) {
 	case Tuple:
 		return NewListFromItems(x)
 	case *List:
 		return x.Copy()
+	default:
+		l := NewList()
+		Iterate(Iter(v), func(item Object) {
+			l.Append(item)
+		})
+		return l
 	}
-	panic(ExceptionNewf(TypeError, "SequenceList not fully implemented, can't convert %s", v.Type().Name))
 }

py/tuple.go

@@ -13,27 +13,12 @@ func (o Tuple) Type() *Type {
 
 // TupleNew
 func TupleNew(metatype *Type, args Tuple, kwargs StringDict) (res Object) {
-	t := Tuple{}
-	defer func() {
-		if r := recover(); r != nil {
-			if IsException(StopIteration, r) {
-				// StopIteration or subclass raised
-				res = t
-			} else {
-				panic(r)
-			}
-		}
-	}()
 	var iterable Object
 	UnpackTuple(args, kwargs, "tuple", 0, 1, &iterable)
-	if iterable == nil {
-		return t
-	}
-	it := Iter(iterable)
-	for {
-		item := Next(it)
-		t = append(t, item)
+	if iterable != nil {
+		return SequenceTuple(iterable)
 	}
+	return Tuple{}
 }
 
 // Copy a tuple object