Logo

Programming-Idioms

  • Pascal
  • VB
  • Lua
  • Java
  • Rust

Idiom #247 Filter list in-place

Remove all the elements from list x that don't satisfy the predicate p, without allocating a new list.
Keep all the elements that do satisfy p.

For languages that don't have mutable lists, refer to idiom #57 instead.

let mut j = 0;
for i in 0..x.len() {
    if p(x[i]) {
        x[j] = x[i];
        j += 1;
    }
}
x.truncate(j);
x.retain(p);

The predicate p takes as argument a reference to the element.
uses classes;
for i := x.count-1 downto 0 do
  if not p(x.items[i]) then x.delete(i);
x.removeIf(p.negate());
#include <functional>
std::erase_if(x, std::not_fn(p));

C++20

Compatible with most STL containers (Exceptions: x cannot be an std::array, std::stack, or std::queue)

std::erase_if also returns the number of elements removed
New implementation...
< > ⌨
programming-idioms.org 
let mut j = 0;
for i in 0..x.len() {
    if p(x[i]) {
        x[j] = x[i];
        j += 1;
    }
}
x.truncate(j);
x.retain(p);
for i := x.count-1 downto 0 do
  if not p(x.items[i]) then x.delete(i);
x.removeIf(p.negate());
std::erase_if(x, std::not_fn(p));
std::list<Foo> x;
x.remove_if(std::not_fn(p));
x.RemoveAll(item => !p(item));
x.retainWhere((e) => p);
x = pack(x,.not.p())
j := 0
for i, v := range x {
	if p(v) {
		x[j] = x[i]
		j++
	}
}
for k := j; k < len(x); k++ {
	x[k] = nil
}
x = x[:j]
j := 0
for i, v := range x {
	if p(v) {
		x[j] = x[i]
		j++
	}
}
x = x[:j]
func Filter[S ~[]T, T any](x *S, p func(T) bool) {
	j := 0
	for i, v := range *x {
		if p(v) {
			(*x)[j] = (*x)[i]
			j++
		}
	}
	var zero T
	for k := j; k < len(*x); k++ {
		(*x)[k] = zero
	}
	*x = (*x)[:j]
}
del := func(t *T) bool { return !p(t) }

x = slices.DeleteFunc(x, del)
for (const [key, value] of x.entries()) {
	if (!p(value)) x.splice(key, 1);
}
x = x.filter((e) => p(e));
@x = grep { p($_) } @x;
del_count = 0
for i in range(len(x)):
    if not p(x[i - del_count]):
        del x[i - del_count]
        del_count += 1
i, n = 0, len(x)
while i != n:
    if not p(x[i]):
        del x[i]
        n = n - 1
    else:
        i = i + 1
x.select!(&:p)