• Ada

function Only_ASCII (S : String) return String is
   subtype ASCII is Character range
      Character'Val (0) .. Character'Val (127);
   T    : String (S'Range);
   Last : Natural := T'First - 1;
begin
   for Char of S loop
      if Char in ASCII then
         Last := Last + 1;
         T (Last) := Char;
      end if;
   end loop;
   return T (T'First .. Last);
end Only_ASCII;

• Clojure

(def t (clojure.string/replace s #"[^\x00-\x7F]" ""))

• C++

 copy_if(begin(src), end(src), back_inserter(dest),
         [](const auto c) { return static_cast<unsigned char>(c) <= 0x7F; });

• C#

string t = Regex.Replace(s, @"[^\u0000-\u007F]+", string.Empty);

• D

auto t = s.filter!(a => a.isASCII).array;

• Dart

var t = '';
for(var c in s.runes) {
  if(c < 128){
    t = t + String.fromCharCode(c);
  }
}

• Elixir

t = for <<c <- s>>, c in 0..127, into: "", do: <<c>>

• Elixir

t = 
  s 
  |> String.to_charlist()
  |> Enum.filter(&(&1 in 0..127))
  |> List.to_string

• Fortran

n = 0
do i=1,len(s)
   if (iachar(s(i:i)) <= 127) n = n + 1
end do
allocate (character(len=n) :: t)
j = 0
do i=1,len(s)
   if (iachar(s(i:i)) <= 127) then
      j = j + 1
      t(j:j) = s(i:i)
   end if
end do

• Go

t := strings.Map(func(r rune) rune {
	if r > unicode.MaxASCII {
		return -1
	}
	return r
}, s)

• Go

re := regexp.MustCompile("[[:^ascii:]]")
t := re.ReplaceAllLiteralString(s, "")

• Haskell

f = filter isAscii
t = f s

• Haskell

t = filter isAscii s

• JS

const t = s.replace(/[^\x00-\x7f]/gu, '')

• JS

const t = [...s].filter(c => c.charCodeAt(0) <= 0x7f).join('')

• Java

String t = s.chars()
    .filter(c -> c < 0x80)
    .mapToObj(x -> valueOf((char) x))
    .collect(joining());

• Java

String t = s.replaceAll("[^\\p{ASCII}]+", "");

• Java

String t = s.replaceAll("[^\\x00-\\x7F]", "");

• Lisp

(remove-if-not (lambda (i) (<= 0 i 127))
               s
               :key #'char-code)

• PHP

$t = preg_replace('/[^[:ascii:]]/', '', $s);

• Pascal

var
  i: integer;
begin
  t := '';
  for i := 1 to length(s) do
    if s[i] < #128 then t := t + s[i];
end.

• Pascal

var
  s,t: string;
begin
  t := ReplaceRegExpr('[^\u0000-\u007F]+', s, '', False);
end.

• Perl

($t = $s) =~ s/[^\x00-\x7f]+//g;

• Perl

$t = decode('ascii', encode('ascii', $s, sub { return '' } ) );

• Python

t = re.sub('[^\u0000-\u007f]', '',  s)

• Python

t = s.encode("ascii", "ignore").decode()

• Python

f = lambda x: ord(x) < 0x80
t = ''.join(filter(f, s))

• Python

t = sub(r'[^\x00-\x7f]', '', s)

• Python

t = sub(r'[^\0-\176]', '', s)

• Ruby

t = s.gsub(/[[:^ascii:]]/, "")

• Ruby

t = s.gsub(/[^[:ascii:]]/, "")

• Rust

let t = s.chars().filter(|c| c.is_ascii()).collect::<String>();

• Rust

let t = s.replace(|c: char| !c.is_ascii(), "");

• Smalltalk

t := s select: [:character | character isAscii].