mutable.Filter duplicates an element

[FGasper]

https://goplay.tools/snippet/n4gxxXL3Tge

package main

import (
	"fmt"

	"github.com/samber/lo/mutable"
)

type el struct {
	Key string
	Val any
}

func main() {
	doc := []el{
		{"foo", 234},
		{"bar", 345},
		{"baz", 111},
	}

	mutable.Filter(
		doc,
		func(e el) bool {
			return e.Key != "bar"
		},
	)

	fmt.Printf("Hello, World! %+v", doc)
}

outputs:

Hello, World! [{Key:foo Val:234} {Key:baz Val:111} {Key:baz Val:111}]

Note the duplicated baz.

[michalb-goflink]

Hello

IMO mutable.Filter is confusing: it modifies input slice in-place (but does not perform expected filtering) and also returns new slice (though promises "in-place").

The code:

https://github.com/samber/lo/blob/v1.53.0/mutable/slice.go#L11

// Filter is a generic function that modifies the input slice in-place to contain only the elements
// that satisfy the provided predicate function. The predicate function takes an element of the slice and its index,
// and should return true for elements that should be kept and false for elements that should be removed.
// The function returns the modified slice, which may be shorter than the original if some elements were removed.
// Note that the order of elements in the original slice is preserved in the output.
// Play: https://go.dev/play/p/0jY3Z0B7O_5
func Filter[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice {

Doc do not match the code

predicate

for predicate does not match the code (no index).

filtering

// Filter is a generic function that modifies the input slice in-place to contain only the elements
// that satisfy the provided predicate function.

It promises filtering in place, but it does not deliver.

Spec

The "spec" at https://pkg.go.dev/github.com/samber/lo#readme-filter says:

Mutable: like lo.Filter(), but the slice is updated in place.

import lom "github.com/samber/lo/mutable"

list := []int{1, 2, 3, 4}
newList := lom.Filter(list, func(x int) bool {
    return x%2 == 0
})

list
// []int{2, 4, 3, 4}

newList
// []int{2, 4}

it matches OP's situation, though looks confusing to me: like, when would I want to use that in-place function

--

Thanks for this great library 👍

[FGasper]

Oof … I didn’t read the doc (or think) carefully enough. Of course, in Go the functionality I want would need a pointer to the slice as an arg.

In my defense …

Consistency

The mutable namespace currently has 6 functions, 4 of which do “useful things” in-place.

Filter and FilterI, though, work differently: they expect you to read a returned result.

These seem better placed in a namespace like volatile, or even back in lo as FilterOverwrite.

Prolixity

mutable.Filter()’s current docs are rather prolix:

Filter is a generic function that modifies the input slice in-place to
contain only the elements that satisfy the provided predicate function.
The predicate function takes an element of the slice and its index,
and should return true for elements that should be kept and false for
elements that should be removed. The function returns the modified slice,
which may be shorter than the original if some elements were removed. Note
that the order of elements in the original slice is preserved in the output.
Play: https://go.dev/play/p/0jY3Z0B7O_5

It could be clearer as something like:

Filter is like lo.Filter but may overwrite the given slice’s buffer.

The doc is also wrong as it stands: Filter’s predicate function does not take the element’s index.

[FGasper]

(For that matter, mutable.Map’s docs say that it returns a slice, which is also untrue.)