Logo

Programming-Idioms

This language bar is your friend. Select your favorite languages!
  • Go

Idiom #57 Filter list

Create the list y containing the items from the list x that satisfy the predicate p. Respect the original ordering. Don't modify x in-place.

func filter[S ~[]T, T any](x S, p func(T) bool) S {
	var y S
	for _, v := range x {
		if p(v) {
			y = append(y, v)
		}
	}
	return y
}

filter is a generic function with a type parameter T
import "slices"
del := func(t *T) bool { return !p(t) }

y := slices.DeleteFunc(slices.Clone(x), del)

Elements have type T.
del (discard) is the opposite of the function p (keep)

We must clone x before deleting some contents.
y := make([]T, 0, len(x))
for _, v := range x{
	if p(v){
		y = append(y, v)
	}
}

For item type T.
Note that this allocates memory for the new slice y.
Warning: y is allocated with as much memory as x, which may in some cases be wasteful.
n := 0
for _, v := range x {
	if p(v) {
		n++
	}
}
y := make([]T, 0, n)
for _, v := range x {
	if p(v) {
		y = append(y, v)
	}
}

This makes 2 passes: one to count the number n of elements to be kept, and one to copy the elements in the target slice created with the correct size n.
This is efficient if p is cheap and x is small.
for Item of X loop
   if P (Item) then
      Y.Append (Item);
   end if;
end loop;
New implementation...
< > ⌨
programming-idioms.org 
func filter[S ~[]T, T any](x S, p func(T) bool) S {
	var y S
	for _, v := range x {
		if p(v) {
			y = append(y, v)
		}
	}
	return y
}
del := func(t *T) bool { return !p(t) }

y := slices.DeleteFunc(slices.Clone(x), del)
y := make([]T, 0, len(x))
for _, v := range x{
	if p(v){
		y = append(y, v)
	}
}
n := 0
for _, v := range x {
	if p(v) {
		n++
	}
}
y := make([]T, 0, n)
for _, v := range x {
	if p(v) {
		y = append(y, v)
	}
}
for Item of X loop
   if P (Item) then
      Y.Append (Item);
   end if;
end loop;
(def y (filter p x))
auto y = x | std::views::filter(p);
std::copy_if (x.begin (), x.end (), std::back_inserter(y), p);

var y = x.Where(p).ToList();
var y = x.FindAll(p);
auto y = [1, 2, 3, 4, 5].filter!(a => a%2==0);

auto y = x.filter!(p);
var y = x.where(p).toList();
y = for item <- x, p.(item), do: item
y = Enum.filter(x, p)
Y = [I || I <- X, P(X)].
Y = lists:filter(P, X).
y = pack(x,mask=p(x))
def y = x.findAll(p)
y = filter p x

y = x.filter(p);
List<T> y = new ArrayList<>();
for (T t : x) if (p.test(t)) y.add(t);
List<T> y = x.stream().filter(p).toList();
val y = x.filter(p)
(setf y (remove-if-not p x))
local y={}
for _,v in ipairs(x) do
 if p(v)==true then 
  table.insert(y,v)
 end
end
y = {}
for _, v in ipairs(x) do
	if p(v) then y[#y+1] = v end
end
NSArray *y=[x filteredArrayUsingPredicate:p];
function p($element) {  /* .... */ }

$y = array_filter ($x, "p");

function Filter(vv:integer):boolean;

begin
  result :=  vv mod 2= 0;
end;

type TFilter=function(v:integer):boolean;

function FilteredArray(const x:TBoundArray;p:TFilter):TBoundArray;
var
  Idx: Integer;
  v : Integer;

begin
  setlength(result,high(x)+1);
  Idx := 0;
  for v in x do
    if p(v) then
    begin
      result[Idx] := v;
      inc(Idx);
    end;
  setlength(result,Idx);
end;
[...]
  y := FilteredArray(x,@Filter);

# You can use a subroutine as your predicate
@primes_less_than_100 = grep { is_prime($_) } 1 .. 99;

# You can also write your predicate inline
@odd_numbers = grep { $_%2 == 1 } 1 .. 99;
y = list(filter(p, x))
y = [element for element in x if p(element)]
y = [*filter(p, x)]
y = x.select(&:p)
let y: Vec<_> = x.iter().filter(p).collect();
val y = x.filter(p)
(define y (filter p x))
y := x select: [:item | item p].