• Python

y = [T(e) for e in x if P(e)]

• Python

y = list(map(T, filter(P, x)))

• Clojure

(def y 
  (eduction (filter P)
            (map T))
            x)

• C++

constexpr auto transform_matches(const auto& x, auto p, auto t) {
    auto result = x 
	| std::views::filter(p)
        | std::views::transform(t);

    std::vector<std::ranges::range_value_t<decltype(result)>> y;
    std::copy(result.begin(), result.end(), std::back_inserter(y));
    return y;
}

• C++

template <typename SeqT>
auto transform_copy_if(const SeqT i, auto p, auto f)
{
 using namespace std;

 SeqT o;

 for_each(begin(i), end(i),
          [&](const auto& x) {
              if(p(x))
               o.push_back(f(x));
          }
         );

 return o;
}

• C#

var y = x.Where(P).Select(T).ToList();

• D

y = x.filter!(P).map!(T);

• Dart

var y = x.where(P).map(T).toList();

• Elixir

y = x
|> Enum.filter(&P/1)
|> Enum.map(&P(&T/1)

• Fortran

y = pack (t(x), mask=p(x))

• Go

var y []Result
for _, e := range x {
	if P(e) {
		y = append(y, T(e))
	}
}

• Groovy

def y = x.findAll(p).collect(t)

• Haskell

y = (map t . filter p) x

• JS

y = x.filter(e => P(e)).map(e => T(e))

• Java

x.stream().filter(P).map(T).collect(Collectors.toList());

• Java

List<T> y = x.stream()
             .filter(P)
             .map(T)
             .toList();

• Lisp

(defvar y (mapcar #'T (remove-if-not p x)))

• PHP

$y = array_map('T', array_filter($x, 'P'));

• Pascal

type
  TListPredicate = function(e: pointer): Boolean;
  TListElementFunc = function(e: pointer): pointer;

function NewList(X: TList; P: TListPredicate; T: TListElementFunc): TList;
var
  e: pointer;
begin
  Result := TList.Create;
  for e in X do
  begin
    if P(e) then
      Result.Add(T(e));
  end;
end;

• Perl

my @y = map { T($_) } grep { P($_) } @x;

• Ruby

y = x.filter_map{|e| t(e) if p(e)}

• Ruby

y = x.each_with_object([]){|e, ar| ar << t(e) if p(e)}

• Rust

let y = x.iter()
	.filter(P)
        .map(T)
	.collect::<Vec<_>>();

• Scala

val y = x.collect { case e if P(e) => T(e) }

• Smalltalk

y := x 
  collect: [:ea | ea t]
  thenSelect: [:ea | ea p].

• Smalltalk

y := x 
  select: [:ea | ea p]
  thenCollect: [:ea | ea t].