py: implement filter

Author: wetor

py/filter.go

@@ -0,0 +1,72 @@
+// Copyright 2023 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)

py/tests/filter.py

@@ -0,0 +1,65 @@
+# test_builtin.py:BuiltinTest.test_filter()
+from libtest import assertRaises
+
+doc="filter"
+class T0:
+    def __bool__(self):
+        return True
+class T1:
+    def __len__(self):
+        return 1
+class T2:
+    def __bool__(self):
+        return False
+class T3:
+    pass
+t0, t1, t2, t3 = T0(), T1(), T2(), T3()
+assert list(filter(None, [t0, t1, t2, t3])) == [t0, t1, t3]
+assert list(filter(None, [1, [], 2, ''])) == [1, 2]
+
+class T3:
+    def __len__(self):
+        raise ValueError
+t3 = T3()
+assertRaises(ValueError, list, filter(None, [t3]))
+
+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"

stdlib/builtin/builtin.go

@@ -77,9 +77,9 @@ func init() {
 		"complex":     py.ComplexType,
 		"dict":        py.StringDictType, // FIXME
 		"enumerate":   py.EnumerateType,
-		// "filter":         py.FilterType,
-		"float":     py.FloatType,
-		"frozenset": py.FrozenSetType,
+		"filter":      py.FilterType,
+		"float":       py.FloatType,
+		"frozenset":   py.FrozenSetType,
 		// "property":       py.PropertyType,
 		"int":  py.IntType, // FIXME LongType?
 		"list": py.ListType,