add ff.Filter, ff.MapFilter, pipe.MapFilter[SrcT, DstT]

pkg/ff/ff_test.go

@@ -41,6 +41,38 @@ func TestMap(t *testing.T) {
 	}
 }
 
+func TestMapFilter(t *testing.T) {
+	a := []int{1, 2, 3, 4, 5, 6, 7, 8}
+
+	fn := func(x int) (string, bool) {
+		return strconv.Itoa(x), x%2 == 0
+	}
+
+	piper := MapFilter(a, fn).Do()
+
+	// Iterate through the values and test the output
+	expected := []string{"2", "4", "6", "8"}
+	for i, val := range piper {
+		require.Equal(t, expected[i], val, "Unexpected result for MapFilter")
+	}
+}
+
+func TestFilter(t *testing.T) {
+	a := []int{1, 2, 3, 4, 5}
+
+	fn := func(x *int) bool {
+		return *x%2 != 0
+	}
+
+	piper := Filter(a, fn).Do()
+
+	// Iterate through the values and test the output
+	expected := []int{1, 3, 5}
+	for i, val := range piper {
+		require.Equal(t, expected[i], val, "Unexpected result for Filter")
+	}
+}
+
 func TestReduce(t *testing.T) {
 	a := []int{1, 2, 3, 4, 5}
 

pkg/ff/filter.go

@@ -0,0 +1,8 @@
+package ff
+
+import "github.com/koss-null/funcfrog/pkg/pipe"
+
+// Filter is a short way to create a Pipe from a slice of SrcT applying Filter function fn.
+func Filter[SrcT any](a []SrcT, fn func(*SrcT) bool) pipe.Piper[SrcT] {
+	return pipe.Slice(a).Filter(fn)
+}

pkg/ff/map_filter.go

@@ -0,0 +1,8 @@
+package ff
+
+import "github.com/koss-null/funcfrog/pkg/pipe"
+
+// MapFilter is a short way to create a Pipe of DstT from a slice of SrcT applying MapFilter function fn.
+func MapFilter[SrcT, DstT any](a []SrcT, fn func(SrcT) (DstT, bool)) pipe.Piper[DstT] {
+	return pipe.MapFilter(pipe.Slice(a), fn)
+}

pkg/pipe/pipe_test.go

@@ -1075,6 +1075,33 @@ func TestPrefixMapNL(t *testing.T) {
 	require.Equal(t, []string{"1", "3", "4"}, res)
 }
 
+func TestPrefixMapFilter(t *testing.T) {
+	res := pipe.MapFilter(
+		pipe.Slice([]int{1, 2, 3, 4, 5}).Filter(
+			func(x *int) bool { return *x != 5 },
+		),
+		func(x int) (string, bool) {
+			return strconv.Itoa(x), x != 2
+		},
+	).Do()
+	require.Equal(t, []string{"1", "3", "4"}, res)
+}
+
+func TestPrefixMapFilterNL(t *testing.T) {
+	t.Parallel()
+
+	res := pipe.MapFilterNL(
+		pipe.Func(func(i int) (int, bool) {
+			a := [...]int{1, 2, 3, 4, 5}
+			return a[i], a[i] != 5
+		}),
+		func(x int) (string, bool) {
+			return strconv.Itoa(x), x != 2
+		},
+	).Gen(5).Do()
+	require.Equal(t, []string{"1", "3", "4"}, res)
+}
+
 func TestPrefixReduce(t *testing.T) {
 	t.Parallel()
 

pkg/pipe/prefixpipe.go

@@ -27,7 +27,7 @@ func Map[SrcT any, DstT any](
 }
 
 // MapNL applies function on a PiperNoLen of type SrcT and returns a Pipe of type DstT.
-func MapNL[SrcT any, DstT any](
+func MapNL[SrcT, DstT any](
 	p PiperNoLen[SrcT],
 	fn func(x SrcT) DstT,
 ) PiperNoLen[DstT] {
@@ -46,9 +46,51 @@ func MapNL[SrcT any, DstT any](
 	}}
 }
 
+// MapFilter applies function on a Piper of type SrcT and returns a Pipe of type DstT.
+// fn returns a value of DstT type and true if this value is not skipped.
+func MapFilter[SrcT, DstT any](
+	p Piper[SrcT],
+	fn func(x SrcT) (DstT, bool),
+) Piper[DstT] {
+	pp := any(p).(entrails[SrcT]).Entrails()
+	return &Pipe[DstT]{internalpipe.Pipe[DstT]{
+		Fn: func(i int) (*DstT, bool) {
+			if obj, skipped := pp.Fn(i); !skipped {
+				dst, exist := fn(*obj)
+				return &dst, !exist
+			}
+			return nil, true
+		},
+		Len:           pp.Len,
+		ValLim:        pp.ValLim,
+		GoroutinesCnt: pp.GoroutinesCnt,
+	}}
+}
+
+// MapFilterNL applies function on a PiperNoLen of type SrcT and returns a Pipe of type DstT.
+// fn returns a value of DstT type and true if this value is not skipped.
+func MapFilterNL[SrcT, DstT any](
+	p PiperNoLen[SrcT],
+	fn func(x SrcT) (DstT, bool),
+) PiperNoLen[DstT] {
+	pp := any(p).(entrails[SrcT]).Entrails()
+	return &PipeNL[DstT]{internalpipe.Pipe[DstT]{
+		Fn: func(i int) (*DstT, bool) {
+			if obj, skipped := pp.Fn(i); !skipped {
+				dst, exist := fn(*obj)
+				return &dst, !exist
+			}
+			return nil, true
+		},
+		Len:           pp.Len,
+		ValLim:        pp.ValLim,
+		GoroutinesCnt: pp.GoroutinesCnt,
+	}}
+}
+
 // Reduce applies reduce operation on Pipe of type SrcT and returns result of type DstT.
 // initVal is an optional parameter to initialize a value that should be used on the first step of reduce.
-func Reduce[SrcT any, DstT any](p Piper[SrcT], fn func(*DstT, *SrcT) DstT, initVal ...DstT) DstT {
+func Reduce[SrcT, DstT any](p Piper[SrcT], fn func(*DstT, *SrcT) DstT, initVal ...DstT) DstT {
 	var init DstT
 	if len(initVal) > 0 {
 		init = initVal[0]