all: support filter builtin feature and fix iterable object

wetor · wetor · commit 80d61cff6b58 · 2023-06-03T15:37:10.000+08:00
diff --git a/py/arithmetic.go b/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
diff --git a/py/dict.go b/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))
 	}
diff --git a/py/exception.go b/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:
diff --git a/py/filter.go b/py/filter.go
@@ -0,0 +1,72 @@
+// Copyright 2018 The go-python Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package py
+
+// A python Filter object
+type Filter struct{
+	it Object
+	fun Object
+}
+
+var FilterType = NewTypeX("filter", `filter(function or None, iterable) --> filter object
+
+Return an iterator yielding those items of iterable for which function(item)
+is true. If function is None, return the items that are true.`,
+	FilterTypeNew, nil)
+
+// Type of this object
+func (f *Filter) Type() *Type{
+	return FilterType
+}
+
+// FilterTypeNew
+func FilterTypeNew(metatype *Type, args Tuple, kwargs StringDict) (res Object, err error){
+	var fun, seq Object
+	var it Object
+	err = UnpackTuple(args, kwargs, "filter", 2, 2, &fun, &seq)
+	if err != nil{
+		return nil, err
+	}
+	it, err = Iter(seq)
+	if err != nil{
+		return nil, err
+	}
+	return &Filter{it: it, fun: fun}, nil
+}
+
+func (f *Filter) M__iter__() (Object, error){
+	return f, nil
+}
+
+func (f *Filter) M__next__() (Object, error){
+	var ok bool
+	for{
+		item, err := Next(f.it)
+		if err != nil{
+			return nil, err
+		}
+		// if (lz->func == Py_None || lz->func == (PyObject *)&PyBool_Type)
+		if _, _ok := f.fun.(Bool); _ok || f.fun == None{
+			ok, err = ObjectIsTrue(item)
+		} else{
+			var good Object
+			good, err = Call(f.fun, Tuple{item}, nil)
+			if err != nil{
+				return nil, err
+			}
+			ok, err = ObjectIsTrue(good)
+		}
+		if ok{
+			return item, nil
+		}
+		if err != nil{
+			return nil, err
+		}
+	}
+}
+
+// Check interface is satisfied
+var _ I__iter__ = (*Filter)(nil)
+var _ I__next__ = (*Filter)(nil)
diff --git a/py/gen.go b/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},
diff --git a/py/internal.go b/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)
+}
diff --git a/py/iterator.go b/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
diff --git a/py/list.go b/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
 }
diff --git a/py/object.go b/py/object.go
@@ -23,24 +23,50 @@ func ObjectRepr(o Object) Object{
 }
 
 // Return whether the object is True or not
-func ObjectIsTrue(o Object) bool{
+func ObjectIsTrue(o Object) (bool, error){
 	if o == True{
-		return true
+		return true, nil
 	}
 	if o == False{
-		return false
+		return false, nil
 	}
 
 	if o == None{
-		return false
+		return false, nil
 	}
 
 	if I, ok := o.(I__bool__); ok{
 		cmp, err := I.M__bool__()
-		if err == nil && cmp == True{
+		if err != nil{
+			return false, err
+		}
+		if cmp == True{
+			return true, nil
+		} else if cmp == False{
+			return false, nil
+		}
+	}
+	if I, ok := o.(I__len__); ok{
+		l, err := I.M__len__()
+		if err != nil{
+			return false, err
+		}
+		if l.(Int) > 0{
+			return true, nil
+		} else{
+			return false, nil
+		}
+	}
+	return false, nil
+}
+
+// Return whether the object is True or not
+func ObjectIsSequence(o Object) bool{
+	if _, ok := o.(I__getitem__); ok{
+		return true
+	} else if t, ok := o.(*Type); ok{
+		if t.GetAttrOrNil("__getitem__") != nil{
 			return true
-		} else if err == nil && cmp == False{
-			return false
 		}
 	}
 	return false
diff --git a/py/tests/filter.py b/py/tests/filter.py
@@ -0,0 +1,44 @@
+# test_builtin.py:BuiltinTest.test_filter()
+from libtest import assertRaises
+
+doc="filter"
+class Squares:
+ def __init__(self, max):
+ self.max = max
+ self.sofar = []
+
+ def __len__(self): return len(self.sofar)
+
+ def __getitem__(self, i):
+ if not 0 <= i < self.max: raise IndexError
+ n = len(self.sofar)
+ while n <= i:
+ self.sofar.append(n*n)
+ n += 1
+ return self.sofar[i]
+
+assert list(filter(lambda c: 'a' <= c <= 'z', 'Hello World')) == list('elloorld')
+assert list(filter(None, [1, 'hello', [], [3], '', None, 9, 0])) == [1, 'hello', [3], 9]
+assert list(filter(lambda x: x > 0, [1, -3, 9, 0, 2])) == [1, 9, 2]
+assert list(filter(None, Squares(10))) == [1, 4, 9, 16, 25, 36, 49, 64, 81]
+assert list(filter(lambda x: x%2, Squares(10))) == [1, 9, 25, 49, 81]
+def identity(item):
+ return 1
+filter(identity, Squares(5))
+assertRaises(TypeError, filter)
+class BadSeq(object):
+ def __getitem__(self, index):
+ if index<4:
+ return 42
+ raise ValueError
+assertRaises(ValueError, list, filter(lambda x: x, BadSeq()))
+def badfunc():
+ pass
+assertRaises(TypeError, list, filter(badfunc, range(5)))
+
+# test bltinmodule.c::filtertuple()
+assert list(filter(None, (1, 2))) == [1, 2]
+assert list(filter(lambda x: x>=3, (1, 2, 3, 4))) == [3, 4]
+assertRaises(TypeError, list, filter(42, (1, 2)))
+
+doc="finished"
diff --git a/py/tests/iter.py b/py/tests/iter.py
@@ -1,6 +1,7 @@
 # Copyright 2019 The go-python Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
+from libtest import assertRaises
 
 doc="iter"
 cnt = 0
@@ -18,4 +19,14 @@ def f():
 words2 = list(iter(words1))
 for w1, w2 in zip(words1, words2):
 assert w1 == w2
+
+# test_builtin.py:BuiltinTest.test_iter()
+assertRaises(TypeError, iter)
+assertRaises(TypeError, iter, 42, 42)
+lists = [("1", "2"), ["1", "2"], "12"]
+for l in lists:
+ i = iter(l)
+ assert next(i) == '1'
+ assert next(i) == '2'
+ assertRaises(StopIteration, next, i)
 doc="finished"
diff --git a/stdlib/builtin/builtin.go b/stdlib/builtin/builtin.go

-Original file line number
+Diff line change
 returnnil, 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
 -funcIter(aObject) (Object, error){
+-
 -ifA, ok:=a.(I__iter__); ok{
 -res, err:=A.M__iter__()
 -iferr!=nil{
 -returnnil, err
 - }
 -ifres!=NotImplemented{
 -returnres, nil
 - }
 - }
+-
 -returnnil, 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
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ func init(){`
`36`	`36`	`returnnil, err`
`37`	`37`	`}`
`38`	`38`	`sMap:=self.(StringDict)`
`39`		`-o:=make([]Object, 0, len(sMap))`
	`39`	`+o:=make(Tuple, 0, len(sMap))`
`40`	`40`	`fork, v:=rangesMap{`
`41`	`41`	`o=append(o, Tuple{String(k), v})`
`42`	`42`	`}`
`@@ -49,7 +49,7 @@ func init(){`
`49`	`49`	`returnnil, err`
`50`	`50`	`}`
`51`	`51`	`sMap:=self.(StringDict)`
`52`		`-o:=make([]Object, 0, len(sMap))`
	`52`	`+o:=make(Tuple, 0, len(sMap))`
`53`	`53`	`fork:=rangesMap{`
`54`	`54`	`o=append(o, String(k))`
`55`	`55`	`}`
`@@ -62,7 +62,7 @@ func init(){`
`62`	`62`	`returnnil, err`
`63`	`63`	`}`
`64`	`64`	`sMap:=self.(StringDict)`
`65`		`-o:=make([]Object, 0, len(sMap))`
	`65`	`+o:=make(Tuple, 0, len(sMap))`
`66`	`66`	`for_, v:=rangesMap{`
`67`	`67`	`o=append(o, v)`
`68`	`68`	`}`
`@@ -204,7 +204,7 @@ func (a StringDict) M__repr__() (Object, error){`
`204`	`204`
`205`	`205`	`// Returns a list of keys from the dict`
`206`	`206`	`func (dStringDict) M__iter__() (Object, error){`
`207`		`-o:=make([]Object, 0, len(d))`
	`207`	`+o:=make(Tuple, 0, len(d))`
`208`	`208`	`fork:=ranged{`
`209`	`209`	`o=append(o, String(k))`
`210`	`210`	`}`
-Original file line number
+Diff line change
 funcIsException(exception*Type, rinterface{}) bool{
 vart*Type
 switchex:=r.(type){
 +caseExceptionInfo:
 +t=ex.Type
 case*Exception:
 t=ex.Type()
 case*Type:
-Original file line number
+Diff line change
@@ @@ -0,0 +1,72 @@ @@
 +// Copyright 2018 The go-python Authors. All rights reserved.
 +// Use of this source code is governed by a BSD-style
 +// license that can be found in the LICENSE file.
++
 +package py
++
 +// A python Filter object
 +typeFilterstruct{
 +itObject
 +funObject
 +}
++
 +varFilterType=NewTypeX("filter", `filter(function or None, iterable) --> filter object
++
 +Return an iterator yielding those items of iterable for which function(item)
 +is true. If function is None, return the items that are true.`,
 +FilterTypeNew, nil)
++
 +// Type of this object
 +func (f*Filter) Type() *Type{
 +returnFilterType
 +}
++
 +// FilterTypeNew
 +funcFilterTypeNew(metatype*Type, argsTuple, kwargsStringDict) (resObject, errerror){
 +varfun, seqObject
 +varitObject
 +err=UnpackTuple(args, kwargs, "filter", 2, 2, &fun, &seq)
 +iferr!=nil{
 +returnnil, err
 + }
 +it, err=Iter(seq)
 +iferr!=nil{
 +returnnil, err
 + }
 +return&Filter{it: it, fun: fun}, nil
 +}
++
 +func (f*Filter) M__iter__() (Object, error){
 +returnf, nil
 +}
++
 +func (f*Filter) M__next__() (Object, error){
 +varokbool
 +for{
 +item, err:=Next(f.it)
 +iferr!=nil{
 +returnnil, err
 + }
 +// if (lz->func == Py_None || lz->func == (PyObject *)&PyBool_Type)
 +if_, _ok:=f.fun.(Bool); _ok||f.fun==None{
 +ok, err=ObjectIsTrue(item)
 + } else{
 +vargoodObject
 +good, err=Call(f.fun, Tuple{item}, nil)
 +iferr!=nil{
 +returnnil, err
 + }
 +ok, err=ObjectIsTrue(good)
 + }
 +ifok{
 +returnitem, nil
 + }
 +iferr!=nil{
 +returnnil, err
 + }
 + }
 +}
++
 +// Check interface is satisfied
 +var_I__iter__= (*Filter)(nil)
 +var_I__next__= (*Filter)(nil)
-Original file line number
+Diff line change
+ }
 returnstring(str), nil
+}
++
 +// Returns an iterator object
 +//
 +// Call __Iter__ Returns an iterator object
 +//
 +// If object is sequence object, create an iterator
 +funcIter(selfObject) (resObject, errerror){
 +ifI, ok:=self.(I__iter__); ok{
 +returnI.M__iter__()
 + } elseifres, ok, err=TypeCall0(self, "__iter__"); ok{
 +returnres, err
 + }
 +ifObjectIsSequence(self){
 +returnNewIterator(self), nil
 + }
 +returnnil, ExceptionNewf(TypeError, "'%s' object is not iterable", self.Type().Name)
 +}
-Original file line number
+Diff line change
 // A python Iterator object
 typeIteratorstruct{
 -Posint
 -Objs []Object
 +Posint
 +SeqObject
+}
 varIteratorType=NewType("iterator", "iterator type")
+}
 // Define a new iterator
 -funcNewIterator(Objs []Object) *Iterator{
 +funcNewIterator(SeqObject) *Iterator{
 m:=&Iterator{
 -Pos: 0,
 -Objs: Objs,
 +Pos: 0,
 +Seq: Seq,
+ }
 returnm
+}
+}
 // Get next one from the iteration
 -func (it*Iterator) M__next__() (Object, error){
 -ifit.Pos>=len(it.Objs){
 -returnnil, StopIteration
 +func (it*Iterator) M__next__() (resObject, errerror){
 +iftuple, ok:=it.Seq.(Tuple); ok{
 +ifit.Pos>=len(tuple){
 +returnnil, StopIteration
 + }
 +res=tuple[it.Pos]
 +it.Pos++
 +returnres, nil
 + }
 +index:=Int(it.Pos)
 +ifI, ok:=it.Seq.(I__getitem__); ok{
 +res, err=I.M__getitem__(index)
 + } elseifres, ok, err=TypeCall1(it.Seq, "__getitem__", index); !ok{
 +returnnil, ExceptionNewf(TypeError, "'%s' object is not iterable", it.Type().Name)
 + }
 +iferr!=nil{
 +ifIsException(IndexError, err){
 +returnnil, StopIteration
 + }
 +returnnil, err
+ }
 -r:=it.Objs[it.Pos]
 it.Pos++
 -returnr, nil
 +returnres, nil
+}
 // Check interface is satisfied
Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ func (l *List) M__bool__() (Object, error){`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`func (l*List) M__iter__() (Object, error){`
`189`		`-returnNewIterator(l.Items), nil`
	`189`	`+returnNewIterator(Tuple(l.Items)), nil`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`func (l*List) M__getitem__(keyObject) (Object, error){`
`@@ -496,7 +496,11 @@ func SortInPlace(l *List, kwargs StringDict, funcName string) error{`
`496`	`496`	`reverse=False`
`497`	`497`	`}`
`498`	`498`	`// FIXME: requires the same bool-check like CPython (or better "\|$Op" that doesn't panic on nil).`
`499`		`-s:=ptrSortable{&sortable{l, keyFunc, ObjectIsTrue(reverse), nil}}`
	`499`	`+ok, err:=ObjectIsTrue(reverse)`
	`500`	`+iferr!=nil{`
	`501`	`+returnerr`
	`502`	`+ }`
	`503`	`+s:=ptrSortable{&sortable{l, keyFunc, ok, nil}}`
`500`	`504`	`sort.Stable(s)`
`501`	`505`	`returns.s.firstErr`
`502`	`506`	`}`
-Original file line number
+Diff line change
+}
 // Return whether the object is True or not
 -funcObjectIsTrue(oObject) bool{
 +funcObjectIsTrue(oObject) (bool, error){
 ifo==True{
 -returntrue
 +returntrue, nil
+ }
 ifo==False{
 -returnfalse
 +returnfalse, nil
+ }
 ifo==None{
 -returnfalse
 +returnfalse, nil
+ }
 ifI, ok:=o.(I__bool__); ok{
 cmp, err:=I.M__bool__()
 -iferr==nil&&cmp==True{
 +iferr!=nil{
 +returnfalse, err
 + }
 +ifcmp==True{
 +returntrue, nil
 + } elseifcmp==False{
 +returnfalse, nil
 + }
 + }
 +ifI, ok:=o.(I__len__); ok{
 +l, err:=I.M__len__()
 +iferr!=nil{
 +returnfalse, err
 + }
 +ifl.(Int) >0{
 +returntrue, nil
 + } else{
 +returnfalse, nil
 + }
 + }
 +returnfalse, nil
 +}
++
 +// Return whether the object is True or not
 +funcObjectIsSequence(oObject) bool{
 +if_, ok:=o.(I__getitem__); ok{
 +returntrue
 + } elseift, ok:=o.(*Type); ok{
 +ift.GetAttrOrNil("__getitem__") !=nil{
 returntrue
 - } elseiferr==nil&&cmp==False{
 -returnfalse
+ }
+ }
 returnfalse
-Original file line number
+Diff line change
@@ @@ -0,0 +1,44 @@ @@
 +# test_builtin.py:BuiltinTest.test_filter()
 +fromlibtestimportassertRaises
++
 +doc="filter"
 +classSquares:
 +def__init__(self, max):
 +self.max=max
 +self.sofar= []
++
 +def__len__(self): returnlen(self.sofar)
++
 +def__getitem__(self, i):
 +ifnot0<=i<self.max: raiseIndexError
 +n=len(self.sofar)
 +whilen<=i:
 +self.sofar.append(n*n)
 +n+=1
 +returnself.sofar[i]
++
 +assertlist(filter(lambdac: 'a'<=c<='z', 'Hello World')) ==list('elloorld')
 +assertlist(filter(None, [1, 'hello', [], [3], '', None, 9, 0])) == [1, 'hello', [3], 9]
 +assertlist(filter(lambdax: x>0, [1, -3, 9, 0, 2])) == [1, 9, 2]
 +assertlist(filter(None, Squares(10))) == [1, 4, 9, 16, 25, 36, 49, 64, 81]
 +assertlist(filter(lambdax: x%2, Squares(10))) == [1, 9, 25, 49, 81]
 +defidentity(item):
 +return1
 +filter(identity, Squares(5))
 +assertRaises(TypeError, filter)
 +classBadSeq(object):
 +def__getitem__(self, index):
 +ifindex<4:
 +return42
 +raiseValueError
 +assertRaises(ValueError, list, filter(lambdax: x, BadSeq()))
 +defbadfunc():
 +pass
 +assertRaises(TypeError, list, filter(badfunc, range(5)))
++
 +# test bltinmodule.c::filtertuple()
 +assertlist(filter(None, (1, 2))) == [1, 2]
 +assertlist(filter(lambdax: x>=3, (1, 2, 3, 4))) == [3, 4]
 +assertRaises(TypeError, list, filter(42, (1, 2)))
++
 +doc="finished"