Generic Functions

C

// No Native Support.
// Common options are macros, void pointers, or separate functions per type.

#define max(a, b) ((a) > (b) ? (a) : (b))

int result = max(10, 20);

C++

template <typename T>
T max_value(T a, T b)
{
	return a > b ? a : b;
}

auto result = max_value(10, 20);

C#

T Identity<T>(T value)
{
	return value;
}

T Max<T>(T left, T right) where T : IComparable<T>
{
	return left.CompareTo(right) >= 0 ? left : right;
}

Java

public static <T> T identity(T value) {
	return value;
}

public static <T extends Comparable<T>> T max(T left, T right) {
	return left.compareTo(right) >= 0 ? left : right;
}

Rust

fn identity<T>(value: T) -> T {
	value
}

fn max_value<T: Ord>(left: T, right: T) -> T {
	if left >= right { left } else { right }
}

Go

// Since Go 1.18
func Identity[T any](value T) T {
	return value
}

func Contains[T comparable](values []T, target T) bool {
	for _, value := range values {
		if value == target {
			return true
		}
	}
	return false
}

Javascript

// No Native Support.
// Javascript functions are dynamically typed.

function identity(value) {
	return value;
}

Typescript

function identity<T>(value: T): T {
	return value;
}

function first<T>(values: T[]): T | undefined {
	return values[0];
}

Python

from typing import TypeVar

T = TypeVar("T")

def identity(value: T) -> T:
	return value

# Since Python 3.12, type parameters can also be declared inline:
def first[T](values: list[T]) -> T | None:
	return values[0] if values else None