• VB

CallByName(receiver, str, CallType.Method)

• VB

Select Case str
    Case NameOf(Foo)
        Foo()
    Case NameOf(Bar)
        Bar()
    Case NameOf(Baz)
        Baz()
    Case NameOf(Barfl)
        Barfl()
End Select

• Clojure

(some-> str {"foo" foo "bar" bar "baz" baz "barfl" barfl} (.call))

• Clojure

(def whitelist #{#'foo #'bar #'baz #'barfl})
(some-> str symbol resolve whitelist (.call))

• Cobol

IDENTIFICATION DIVISION.
PROGRAM-ID. reverse string.
PROCEDURE DIVISION.
    EVALUATE str
       WHEN foo
	  PERFORM foo
       WHEN bar
          PERFORM bar
       WHEN baz
	  PERFORM baz 
       WHEN barfl
	  PERFORM barfl
       WHEN OTHER
	  CONTINUE
    END-EVALUATE.	
STOP RUN.

• C#

switch (str)
{
    case nameof(Foo):
        Foo();
        break;
    case nameof(Bar):
        Bar();
        break;
    case nameof(Baz):
        Baz();
        break;
    case nameof(Barfl):
        Barfl();
        break;
}

• Dart

var myProc = {"foo": foo, 
              "bar": bar, 
              "baz": baz, 
              "barfl": barfl};

myProc[str]?.call();

• Fortran

  select case (str)
  case ("foo")
     call foo
  case ("bar")
     call bar
  case ("baz")
     call baz
  case ("barfl")
     call barfl
  end select

• Go

switch str {
case "foo":
	foo()
case "bar":
	bar()
case "baz":
	baz()
case "barfl":
	barfl()
}

• Haskell

case str of
  "foo" -> foo
  "bar" -> bar
  "baz" -> baz
  "barfl" -> barfl

• JS

switch (str) {
  case "foo":
    foo();
    break;
  case "bar":
    bar();
    break;
  case "baz":
    baz();
    break;
  case "barfl":
    barfl();
    break;
}

• Java

switch (str){
	case "bar":
            bar();
            break;
        case "baz":
            baz();
            break;
        case "foo":
            foo();
            break;
        case "barfl":
            barfl();
            break;
        default:
            somethingElse();
    }

• Java

switch (str) {
    case "foo" -> foo();
    case "bar" -> bar();
    case "baz" -> baz();
    case "barfl" -> barfl();
}

• Lua

local procedures={
 foo=function() end,
 bar=function() end,
 baz=function() end,
 barfl=function() end,
}
local function process(str)
 local procedure=procedures[str]
 if procedure~=nil then
  procedure()
 end
end
process(str)

• PHP

switch ($str) {
  case "foo":
    foo();
    break;
  case "bar":
    bar();
    break;
  case "baz":
    baz();
    break;
  case "barfl":
    barfl();
    break;
}

• Pascal

case str of
  'foo': foo;
  'bar': bar;
  'baz': baz;
  'barfl': barfl;
end;

• Perl

my %proc = map { $_ => \&$_ } qw(foo bar baz barfl);
$proc{$str}->() if exists $proc{$str};

• Python

switch = {'foo': foo, 
	'bar': bar, 
	'baz': baz, 
	'barfl': barfl
	}

switch_funct = switch.get(string)
if switch_funct : switch_funct()

• Python

match str:
    case 'foo': foo()
    case 'bar': bar()
    case 'baz': baz()
    case 'barfl': barfl()

• Ruby

method(str).call if ["foo", "bar", "baz", "barfl"].include?(str)

• Rust

match str {
    "foo" => foo(),
    "bar" => bar(),
    "baz" => baz(),
    "barfl" => barfl(),
    _ => {}
}