• Pascal

type
  TPairedList = class(TStringList)
  private
    FBuddy: TStrings;
  protected
    procedure ExchangeItems(Id1, Id2: Integer); override;
  public
    procedure Sort(Buddy: TStrings); overload;
  end;

procedure TPairedList.ExchangeItems(Id1, Id2: Integer);
begin
  inherited Exchange(Id1, Id2);
  if Assigned(FBuddy) then
    FBuddy.Exchange(Id1, Id2);
end;

procedure TPairedList.Sort(Buddy: TStrings);
begin
  FBuddy := Buddy;
  Sort;
end;

begin
  ...
  a.sort(b);
end.

• Clojure

(->> (map vector a b)
     (sort-by first)
     (apply (partial mapv vector)))

• Go

type sorter struct {
	k []K
	t []T
}

func (s *sorter) Len() int {
	return len(s.k)
}

func (s *sorter) Swap(i, j int) {
	s.k[i], s.k[j] = s.k[j], s.k[i]
	s.t[i], s.t[j] = s.t[j], s.t[i]
}

func (s *sorter) Less(i, j int) bool {
	return s.k[i] < s.k[j]
}

sort.Sort(&sorter{
	k: a,
	t: b,
})

• Haskell

let (outA,outB) = unzip $ sort $ zip a b

• Perl

@keys = qw(x y a f e n);
@vals = qw(1 2 3 4 5 6);

pairmap { push @new_keys, $a; push @new_vals, $b }
    unpairs 
        sort { $a->[0] cmp $b->[0] } 
            zip \@keys, \@vals;

• Python

temp = list(zip(a, b))
temp.sort(key=operator.itemgetter(0))
a, b = zip(*work)

• Ruby

a, b = a.zip(b).sort.transpose

• Rust

let mut tmp: Vec<_> = a.iter().zip(b).collect();
tmp.as_mut_slice().sort_by_key(|(&x, _y)| x);
let (aa, bb): (Vec<i32>, Vec<i32>) = tmp.into_iter().unzip();