• Scheme

(define (foo x)
  (displayln
   (if (string? x)
       x
       "Nothing")))

(foo "Hello, world!")
(foo 42)

• Clojure

(defn foo [x]
  (println (if (string? x) x "Nothing.")))

(foo "Hello, world!")
(foo 42)

• C#

void foo(object x)
{
    if (x is string s)
    {
        Console.WriteLine(s);
    }
    else
    {
        Console.WriteLine("Nothing.");
    }
}

foo("Hello, world!");
foo(42);

• C#

void foo<T>(T x)
{
    if (x is string s)
    {
        Console.WriteLine(s);
    }
    else
    {
        Console.WriteLine("Nothing.");
    }
}

foo("Hello, world!");
foo(42);

• Dart

foo(x) => print(x is String ? x : 'Nothing.');

foo('Hello, world!');
foo(42);

• Fortran

program main
  call foo("Hello, world!")
  call foo(42)
contains
  subroutine foo(x)
    class(*), intent(in) :: x
    select type(x)
    type is (character(len=*))
       write (*,'(A)') x
    class default
       write (*,'(A)') "Nothing."
    end select
  end subroutine foo
end program main

• Go

func foo(x any) {
	if s, ok := x.(string); ok {
		fmt.Println(s)
	} else {
		fmt.Println("Nothing.")
	}
}

func main() {
	foo("Hello, world!")
	foo(42)
}

• JS

function foo(x) {
  console.log(typeof x == 'string' ? x : 'Nothing.')
}

foo('Hello, world!')
foo(42)

• Java

    public static void main(String[] args) {
        foo("Hello, world!");
        foo(42);
    }

    private static void foo(Object x) {
        if (x instanceof String) {
            System.out.println(x);
        } else {
            System.out.println("Nothing.");
        }
    }

• Java

<T> void foo(T x) {
    if (x instanceof String) out.println(x);
    else out.println("Nothing.");
}

• Java

interface F<T> { void set(T x); }
F<Object> foo = x -> {
    if (x instanceof String) out.println(x);
    else out.println("Nothing.");
};
foo.set("Hello, world!");
foo.set(42);

• Pascal

procedure foo(const x: variant);
begin
  case (TVarData(x).vType and varTypeMask) of
    varOleStr, varUString, varString: writeln(x);
    otherwise writeln('Nothing');
  end;
end;

begin
  foo('Hello World');
  foo(42);
end.

• Perl

sub foo {
    my ($x) = @_;
    return 'Nothing' if ref $x ne '' or looks_like_number($x);   
    return $x;
}

$\ = "\n"; # print with newline
say foo( [] );
say foo( 42 );
say foo( 'Hello World' );

• Perl

sub foo {
    my ($s, $x) = @_;
    return 'is undefined'   if not defined $x;
    return 'is a reference' if ref $x ne '';
    return 'is a number'    if looks_like_number $s;
    return 'is a string';
}

• Python

def foo(x):
    if isinstance(x, str):
        print(x)
    else:
        print('Nothing.')
    return

foo('Hello, world!')
foo(42)

• Python

foo = lambda x: \
    print(x if type(x) is str else 'Nothing.')
foo('Hello, world!')
foo(42)

• Ruby

def foo(x)
  puts x.class == String ? x : "Nothing"
end

foo("Hello, world")
foo(42)

• Rust

fn foo(x: &dyn Any) {
    if let Some(s) = x.downcast_ref::<String>() {
        println!("{}", s);
    } else {
        println!("Nothing")
    }
}

fn main() {
    foo(&"Hello, world!".to_owned());
    foo(&42);
}