Logo

Programming-Idioms

This language bar is your friend. Select your favorite languages!
  • Go

Idiom #225 Declare and use an optional argument

Declare an optional integer argument x to procedure f, printing out "Present" and its value if it is present, "Not present" otherwise

func f(x ...int) {
	if len(x) > 0 {
		println("Present", x[0])
	} else {
		println("Not present")
	}
}

Go does not have optional arguments, but to some extend, they can be mimicked with a variadic parameter.
x is a variadic parameter, which must be the last parameter for the function f.
Strictly speaking, x is a list of integers, which might have more than one element. These additional elements are ignored.
(defn f [& [x]]
  (if (integer? x)
    (println "Present" x)
    (println "Not present")))

Optional argument with positional parameters
New implementation...
< > ⌨
tkoenig 
func f(x ...int) {
	if len(x) > 0 {
		println("Present", x[0])
	} else {
		println("Not present")
	}
}
(defn f [& [x]]
  (if (integer? x)
    (println "Present" x)
    (println "Not present")))
(defn f 
  ([] (println "Not present"))
  ([x] (println "Present" x)))
void f(std::optional<int> x = {}) {
  std::cout << (x ? "Present" + std::to_string(x.value()) : "Not Present");
}
void f(std::optional<int> x = {}) {
  if (x) {
    std::cout << "Present" << x.value();
  } else {
    std::cout << "Not present";
  }
}
void f(int? x = null)
{
    Console.WriteLine(x.HasValue ? $"Present {x}" : "Not Present");
}
void f({int? x}) => print(x == null ? "Not present" : "Present");
subroutine f(x)
  integer, optional :: x
  if (present(x)) then
    print *,"Present", x
  else
    print *,"Not present"
  end if
end subroutine f
   
function f(x) {
	console.log(x ? `Present: ${x}` : 'Not present');
}
void f() { set(null); }
void f(int x) { set(x); }
private void set(Integer t) {
    if (t != null) out.println("Present");
    else out.println("Not present");
}
void f(int ... x) {
    if (x.length != 0) out.println("Present");
    else out.println("Not present");
}
private void f(Integer x) {
    if (x != null) {
        System.out.println("Present " + x);
    } else {
        System.out.println("Not present");
    }
}
function f( x )
	if x then
		print("Present", x)
	else
		print("Not present")
	end
end
function f(?int $x = null) {
    echo $x ? 'Present' . $x : 'Not present';
}
procedure f; overload;
begin
  writeln('not present');
end;

procedure f(x: integer); overload;
begin
  writeln('present');
end;
sub f {
    my $x = shift;
    if (defined $x) {
        print("Present $x\n");
    }
    else {
        print("Not Present\n");
    }
}
def f(x=None):
    if x is None:
        print("Not present")
    else:
        print("Present", x)
def f( x=nil )
  puts x ? "present" : "not present"
end

fn f(x: Option<()>) {
    match x {
        Some(x) => println!("Present {}", x),
        None => println!("Not present"),
    }
}
Sub f(Optional x As Integer? = Nothing)
    Console.WriteLine(If(x.HasValue, $"Present {x}", "Not Present"))
End Sub