Logo

Programming-Idioms

Declare an argument x to a procedure foo that can be of any type. If the type of the argument is a string, print it, otherwise print "Nothing."

Test by passing "Hello, world!" and 42 to the procedure.
New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

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

(foo "Hello, world!")
(foo 42)
using System;
void foo<T>(T x)
{
    if (x is string s)
    {
        Console.WriteLine(s);
    }
    else
    {
        Console.WriteLine("Nothing.");
    }
}

foo("Hello, world!");
foo(42);
using System;
void foo(object x)
{
    if (x is string s)
    {
        Console.WriteLine(s);
    }
    else
    {
        Console.WriteLine("Nothing.");
    }
}

foo("Hello, world!");
foo(42);
foo(x) => print(x is String ? x : 'Nothing.');

foo('Hello, world!');
foo(42);
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
import "fmt"
func foo(x any) {
	if s, ok := x.(string); ok {
		fmt.Println(s)
	} else {
		fmt.Println("Nothing.")
	}
}

func main() {
	foo("Hello, world!")
	foo(42)
}
function foo(x) {
  console.log(typeof x == 'string' ? x : 'Nothing.')
}

foo('Hello, world!')
foo(42)
    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.");
        }
    }
variants
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.
use v5.10;
useScalar::Util 'looks_like_number';
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' );
use Scalar::Util qw(looks_like_number);
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';
}
def foo(x):
    if isinstance(x, str):
        print(x)
    else:
        print('Nothing.')
    return

foo('Hello, world!')
foo(42)
def foo(x)
  puts x.class == String ? x : "Nothing"
end

foo("Hello, world")
foo(42)
use std::any::Any;
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);
}
(define (foo x)
  (displayln
   (if (string? x)
       x
       "Nothing")))

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