Long press code to compare

Variables

typescript python

int x = 10;
std::string name = "Alice";
bool active = true;

var x int = 10
var name string = "Alice"
var active bool = true

int x = 10;
String name = "Alice";
boolean active = true;

x = 10
name = "Alice"
active = True

let x: i32 = 10;
let name: &str = "Alice";
let active: bool = true;
let mut count: i32 = 0;

let x: number = 10;
let name: string = "Alice";
let active: boolean = true;
var legacy: number = 0;

int x = 10;
std::string name = "Alice";
bool active = true;

var x int = 10
var name string = "Alice"
var active bool = true

int x = 10;
String name = "Alice";
boolean active = true;

x = 10
name = "Alice"
active = True

let x: i32 = 10;
let name: &str = "Alice";
let active: bool = true;
let mut count: i32 = 0;

let x: number = 10;
let name: string = "Alice";
let active: boolean = true;
var legacy: number = 0;

auto [a, b, c] = std::tuple{1, 2, 3};
auto [x, y] = std::pair{10, 20};
std::swap(x, y);

var a, b, c int = 1, 2, 3
x, y := 10, 20
x, y = y, x

// Java has no multiple assignment — use individual declarations
int a = 1, b = 2, c = 3;
int x = 10, y = 20;
int temp = x; x = y; y = temp;

a, b, c = 1, 2, 3
x, y = 10, 20
x, y = y, x

let (a, b, c) = (1, 2, 3);
let (mut x, mut y) = (10, 20);
std::mem::swap(&mut x, &mut y);

let [a, b, c] = [1, 2, 3];
let [x, y] = [10, 20];
[x, y] = [y, x];

auto [a, b, c] = std::tuple{1, 2, 3};
auto [x, y] = std::pair{10, 20};
std::swap(x, y);

var a, b, c int = 1, 2, 3
x, y := 10, 20
x, y = y, x

// Java has no multiple assignment — use individual declarations
int a = 1, b = 2, c = 3;
int x = 10, y = 20;
int temp = x; x = y; y = temp;

a, b, c = 1, 2, 3
x, y = 10, 20
x, y = y, x

let (a, b, c) = (1, 2, 3);
let (mut x, mut y) = (10, 20);
std::mem::swap(&mut x, &mut y);

let [a, b, c] = [1, 2, 3];
let [x, y] = [10, 20];
[x, y] = [y, x];

constexpr double PI = 3.14159;
constexpr int MAX_SIZE = 100;
enum class Status {
    OK = 200,
    Error = 500,
};

const Pi = 3.14159
const MaxSize int = 100
const (
    StatusOK    = 200
    StatusError = 500
)

static final double PI = 3.14159;
static final int MAX_SIZE = 100;
enum Status {
    OK(200),
    ERROR(500);
    final int code;
    Status(int code) { this.code = code; }
}

PI = 3.14159
MAX_SIZE = 100
from enum import IntEnum
class Status(IntEnum):
    OK = 200
    ERROR = 500

const PI: f64 = 3.14159;
const MAX_SIZE: usize = 100;
static GREETING: &str = "Hello";

const PI = 3.14159;
const MAX_SIZE: number = 100;
const enum Status {
    OK = 200,
    Error = 500,
}

constexpr double PI = 3.14159;
constexpr int MAX_SIZE = 100;
enum class Status {
    OK = 200,
    Error = 500,
};

const Pi = 3.14159
const MaxSize int = 100
const (
    StatusOK    = 200
    StatusError = 500
)

static final double PI = 3.14159;
static final int MAX_SIZE = 100;
enum Status {
    OK(200),
    ERROR(500);
    final int code;
    Status(int code) { this.code = code; }
}

PI = 3.14159
MAX_SIZE = 100
from enum import IntEnum
class Status(IntEnum):
    OK = 200
    ERROR = 500

const PI: f64 = 3.14159;
const MAX_SIZE: usize = 100;
static GREETING: &str = "Hello";

const PI = 3.14159;
const MAX_SIZE: number = 100;
const enum Status {
    OK = 200,
    Error = 500,
}

auto x = 42;
auto name = std::string("Alice");
auto ratio = 3.14;
auto active = true;

x := 42
name := "Alice"
ratio := 3.14
active := true

var x = 42;
var name = "Alice";
var ratio = 3.14;
var active = true;

x = 42
name = "Alice"
ratio = 3.14
active = True

let x = 42;
let name = "Alice";
let ratio = 3.14;
let active = true;

let x = 42;
let name = "Alice";
let ratio = 3.14;
let active = true;

auto x = 42;
auto name = std::string("Alice");
auto ratio = 3.14;
auto active = true;

x := 42
name := "Alice"
ratio := 3.14
active := true

var x = 42;
var name = "Alice";
var ratio = 3.14;
var active = true;

x = 42
name = "Alice"
ratio = 3.14
active = True

let x = 42;
let name = "Alice";
let ratio = 3.14;
let active = true;

let x = 42;
let name = "Alice";
let ratio = 3.14;
let active = true;

Data Types

typescript python

int num = 42;
double pi = 3.14;
std::string name = "hello";
bool active = true;
char ch = 'A';

var num int = 42
var pi float64 = 3.14
var name string = "hello"
var active bool = true
var b byte = 'A'

int num = 42;
double pi = 3.14;
String name = "hello";
boolean active = true;
char ch = 'A';

num = 42
pi = 3.14
name = "hello"
active = True
nothing = None

let num: i32 = 42;
let pi: f64 = 3.14;
let name: &str = "hello";
let active: bool = true;
let ch: char = 'A';

let num: number = 42;
let pi: number = 3.14;
let name: string = "hello";
let active: boolean = true;
let nothing: null = null;

int num = 42;
double pi = 3.14;
std::string name = "hello";
bool active = true;
char ch = 'A';

var num int = 42
var pi float64 = 3.14
var name string = "hello"
var active bool = true
var b byte = 'A'

int num = 42;
double pi = 3.14;
String name = "hello";
boolean active = true;
char ch = 'A';

num = 42
pi = 3.14
name = "hello"
active = True
nothing = None

let num: i32 = 42;
let pi: f64 = 3.14;
let name: &str = "hello";
let active: bool = true;
let ch: char = 'A';

let num: number = 42;
let pi: number = 3.14;
let name: string = "hello";
let active: boolean = true;
let nothing: null = null;

#include <typeinfo>
typeid(num).name();              // "i" (compiler-dependent)
std::is_same_v<decltype(num), int>; // true
std::is_integral_v<int>;         // true
std::is_floating_point_v<double>; // true

import "fmt"
fmt.Printf("%T\n", num)      // int
fmt.Printf("%T\n", pi)       // float64
fmt.Printf("%T\n", name)     // string
var i interface{} = 42
v, ok := i.(int)             // type assertion

Integer.class.getName();         // "java.lang.Integer"
name instanceof String;          // true
name.getClass().getSimpleName(); // "String"
if (obj instanceof String s) {   // pattern matching (Java 16+)
    System.out.println(s.length());
}

type(num)                  # <class 'int'>
type(pi)                   # <class 'float'>
isinstance(num, int)       # True
isinstance(active, bool)   # True
isinstance(num, (int, float))  # multiple types

fn type_of<T>(_: &T) -> &'static str {
    std::any::type_name::<T>()
}
println!("{}", type_of(&num));    // "i32"
println!("{}", type_of(&name));   // "&str"
let val: Box<dyn std::any::Any> = Box::new(42_i32);
val.downcast_ref::<i32>().is_some()  // true

typeof num;                     // "number"
typeof name;                    // "string"
typeof nothing;                 // "object" (JS quirk)
Array.isArray([1, 2]);          // true
function isString(val: unknown): val is string {
    return typeof val === "string";
}

#include <typeinfo>
typeid(num).name();              // "i" (compiler-dependent)
std::is_same_v<decltype(num), int>; // true
std::is_integral_v<int>;         // true
std::is_floating_point_v<double>; // true

import "fmt"
fmt.Printf("%T\n", num)      // int
fmt.Printf("%T\n", pi)       // float64
fmt.Printf("%T\n", name)     // string
var i interface{} = 42
v, ok := i.(int)             // type assertion

Integer.class.getName();         // "java.lang.Integer"
name instanceof String;          // true
name.getClass().getSimpleName(); // "String"
if (obj instanceof String s) {   // pattern matching (Java 16+)
    System.out.println(s.length());
}

type(num)                  # <class 'int'>
type(pi)                   # <class 'float'>
isinstance(num, int)       # True
isinstance(active, bool)   # True
isinstance(num, (int, float))  # multiple types

fn type_of<T>(_: &T) -> &'static str {
    std::any::type_name::<T>()
}
println!("{}", type_of(&num));    // "i32"
println!("{}", type_of(&name));   // "&str"
let val: Box<dyn std::any::Any> = Box::new(42_i32);
val.downcast_ref::<i32>().is_some()  // true

typeof num;                     // "number"
typeof name;                    // "string"
typeof nothing;                 // "object" (JS quirk)
Array.isArray([1, 2]);          // true
function isString(val: unknown): val is string {
    return typeof val === "string";
}

auto s = std::to_string(42);        // "42"
auto n = std::stoi("42");           // 42
auto f = std::stod("3.14");         // 3.14
auto t = static_cast<int>(3.7);     // 3 (truncates)
auto d = static_cast<double>(42);   // 42.0

var i int = 42
var f float64 = float64(i)
var s string = strconv.Itoa(i)
var n, _ = strconv.Atoi("42")
var r float64 = float64(int(3.7))

String s = String.valueOf(42);       // "42"
int n = Integer.parseInt("42");      // 42
double f = Double.parseDouble("3.14"); // 3.14
int t = (int) 3.7;                  // 3 (truncates)
double d = (double) 42;             // 42.0

str_num = str(42)          # "42"
num_str = int("42")        # 42
floated = float("3.14")    # 3.14
rounded = int(3.7)         # 3 (truncates)
as_list = list("abc")      # ["a", "b", "c"]

let i: i32 = 42;
let f: f64 = i as f64;
let s: String = i.to_string();
let n: i32 = "42".parse().unwrap();
let truncated: i32 = 3.7_f64 as i32;

let s: string = String(42);          // "42"
let n: number = Number("42");        // 42
let f: number = parseFloat("3.14");  // 3.14
let t: number = Math.trunc(3.7);     // 3
let b: boolean = Boolean("");        // false

auto s = std::to_string(42);        // "42"
auto n = std::stoi("42");           // 42
auto f = std::stod("3.14");         // 3.14
auto t = static_cast<int>(3.7);     // 3 (truncates)
auto d = static_cast<double>(42);   // 42.0

var i int = 42
var f float64 = float64(i)
var s string = strconv.Itoa(i)
var n, _ = strconv.Atoi("42")
var r float64 = float64(int(3.7))

String s = String.valueOf(42);       // "42"
int n = Integer.parseInt("42");      // 42
double f = Double.parseDouble("3.14"); // 3.14
int t = (int) 3.7;                  // 3 (truncates)
double d = (double) 42;             // 42.0

str_num = str(42)          # "42"
num_str = int("42")        # 42
floated = float("3.14")    # 3.14
rounded = int(3.7)         # 3 (truncates)
as_list = list("abc")      # ["a", "b", "c"]

let i: i32 = 42;
let f: f64 = i as f64;
let s: String = i.to_string();
let n: i32 = "42".parse().unwrap();
let truncated: i32 = 3.7_f64 as i32;

let s: string = String(42);          // "42"
let n: number = Number("42");        // 42
let f: number = parseFloat("3.14");  // 3.14
let t: number = Math.trunc(3.7);     // 3
let b: boolean = Boolean("");        // false

int* ptr = nullptr;
std::optional<int> maybe = std::nullopt;
std::optional<int> some = 42;
if (some.has_value()) {
    std::cout << some.value() << "\n";
}
int fallback = maybe.value_or(0);

var zeroInt int       // 0
var zeroStr string    // ""
var zeroBool bool     // false
var ptr *int          // nil (pointers only)
var s []int           // nil (slices, maps, channels)

String nullable = null;
Optional<Integer> maybe = Optional.empty();
Optional<Integer> some = Optional.of(42);
if (some.isPresent()) {
    System.out.println(some.get());
}
int fallback = maybe.orElse(0);

bool(0)       # False
bool("")      # False
bool(None)    # False
bool("hi")    # True
bool([])      # False (empty collections are falsy)

let some_val: Option<i32> = Some(42);
let no_val: Option<i32> = None;
if let Some(v) = some_val {
    println!("Got: {}", v);
}
let fallback = no_val.unwrap_or(0);

let a: null = null;
let b: undefined = undefined;
let maybe: string | null = null;
let union: string | undefined = undefined;
type Optional = string | null | undefined;

int* ptr = nullptr;
std::optional<int> maybe = std::nullopt;
std::optional<int> some = 42;
if (some.has_value()) {
    std::cout << some.value() << "\n";
}
int fallback = maybe.value_or(0);

var zeroInt int       // 0
var zeroStr string    // ""
var zeroBool bool     // false
var ptr *int          // nil (pointers only)
var s []int           // nil (slices, maps, channels)

String nullable = null;
Optional<Integer> maybe = Optional.empty();
Optional<Integer> some = Optional.of(42);
if (some.isPresent()) {
    System.out.println(some.get());
}
int fallback = maybe.orElse(0);

bool(0)       # False
bool("")      # False
bool(None)    # False
bool("hi")    # True
bool([])      # False (empty collections are falsy)

let some_val: Option<i32> = Some(42);
let no_val: Option<i32> = None;
if let Some(v) = some_val {
    println!("Got: {}", v);
}
let fallback = no_val.unwrap_or(0);

let a: null = null;
let b: undefined = undefined;
let maybe: string | null = null;
let union: string | undefined = undefined;
type Optional = string | null | undefined;

Operators

typescript python

int x = 10 + 3;     // 13
int y = 10 - 3;     // 7
int z = 10 * 3;     // 30
int d = 10 / 3;     // 3 (integer division)
int m = 10 % 3;     // 1
int p = 1 << 3;     // 8 (bitwise shift)

x := 10 + 3     // 13
y := 10 - 3     // 7
z := 10 * 3     // 30
d := 10 / 3     // 3 (integer division)
m := 10 % 3     // 1
p := 1 << 3     // 8 (bitwise shift)

int x = 10 + 3;     // 13
int y = 10 - 3;     // 7
int z = 10 * 3;     // 30
int d = 10 / 3;     // 3 (integer division)
int m = 10 % 3;     // 1
double p = Math.pow(2, 3); // 8.0

x = 10 + 3     # 13
y = 10 - 3     # 7
z = 10 * 3     # 30
d = 10 / 3     # 3.333... (true division)
f = 10 // 3    # 3 (floor division)
m = 10 % 3     # 1
p = 2 ** 3     # 8 (exponentiation)

let x = 10 + 3;     // 13
let y = 10 - 3;     // 7
let z = 10 * 3;     // 30
let d = 10 / 3;     // 3 (integer division)
let m = 10 % 3;     // 1
let p = 1_i32 << 3; // 8 (bitwise shift)

let x = 10 + 3;     // 13
let y = 10 - 3;     // 7
let z = 10 * 3;     // 30
let d = 10 / 3;     // 3.333... (no integer division)
let m = 10 % 3;     // 1
let p = 2 ** 3;     // 8 (exponentiation)

int x = 10 + 3;     // 13
int y = 10 - 3;     // 7
int z = 10 * 3;     // 30
int d = 10 / 3;     // 3 (integer division)
int m = 10 % 3;     // 1
int p = 1 << 3;     // 8 (bitwise shift)

x := 10 + 3     // 13
y := 10 - 3     // 7
z := 10 * 3     // 30
d := 10 / 3     // 3 (integer division)
m := 10 % 3     // 1
p := 1 << 3     // 8 (bitwise shift)

int x = 10 + 3;     // 13
int y = 10 - 3;     // 7
int z = 10 * 3;     // 30
int d = 10 / 3;     // 3 (integer division)
int m = 10 % 3;     // 1
double p = Math.pow(2, 3); // 8.0

x = 10 + 3     # 13
y = 10 - 3     # 7
z = 10 * 3     # 30
d = 10 / 3     # 3.333... (true division)
f = 10 // 3    # 3 (floor division)
m = 10 % 3     # 1
p = 2 ** 3     # 8 (exponentiation)

let x = 10 + 3;     // 13
let y = 10 - 3;     // 7
let z = 10 * 3;     // 30
let d = 10 / 3;     // 3 (integer division)
let m = 10 % 3;     // 1
let p = 1_i32 << 3; // 8 (bitwise shift)

let x = 10 + 3;     // 13
let y = 10 - 3;     // 7
let z = 10 * 3;     // 30
let d = 10 / 3;     // 3.333... (no integer division)
let m = 10 % 3;     // 1
let p = 2 ** 3;     // 8 (exponentiation)

std::cout << (5 == 5);     // 1 (true)
std::cout << (5 != 3);     // 1 (true)
std::cout << (5 > 3);      // 1 (true)
std::cout << (5 <= 5);     // 1 (true)
std::string a = "hi";
std::string b = "hi";
std::cout << (a == b);     // 1 (value equality for strings)

fmt.Println(5 == 5)    // true
fmt.Println(5 != 3)    // true
fmt.Println(5 > 3)     // true
fmt.Println(5 <= 5)    // true
a := [2]int{1, 2}
b := [2]int{1, 2}
fmt.Println(a == b)    // true (arrays are comparable)

System.out.println(5 == 5);       // true (primitives)
String a = "hi";
String b = "hi";
System.out.println(a.equals(b));  // true (value equality)
System.out.println(a == b);       // true (interned strings)
System.out.println(new String("hi") == new String("hi")); // false!

5 == 5.0       # True (value equality)
5 is 5         # True (identity, small ints)
[1] == [1]     # True (value equality)
[1] is [1]     # False (different objects)
x is None      # idiomatic None check
1 < 2 < 3      # True (chained comparison)

println!("{}", 5 == 5);    // true
println!("{}", 5 != 3);    // true
println!("{}", 5 > 3);     // true
println!("{}", 5 <= 5);    // true
let a = (1, 2);
let b = (1, 2);
println!("{}", a == b);    // true (tuples are comparable)

5 === 5;              // true (strict equality)
5 !== "5";            // true (strict inequality)
5 == "5";             // avoid: loose equality with coercion
null == undefined;    // true (loose only)
null === undefined;   // false (strict)
NaN === NaN;          // false (use Number.isNaN)

std::cout << (5 == 5);     // 1 (true)
std::cout << (5 != 3);     // 1 (true)
std::cout << (5 > 3);      // 1 (true)
std::cout << (5 <= 5);     // 1 (true)
std::string a = "hi";
std::string b = "hi";
std::cout << (a == b);     // 1 (value equality for strings)

fmt.Println(5 == 5)    // true
fmt.Println(5 != 3)    // true
fmt.Println(5 > 3)     // true
fmt.Println(5 <= 5)    // true
a := [2]int{1, 2}
b := [2]int{1, 2}
fmt.Println(a == b)    // true (arrays are comparable)

System.out.println(5 == 5);       // true (primitives)
String a = "hi";
String b = "hi";
System.out.println(a.equals(b));  // true (value equality)
System.out.println(a == b);       // true (interned strings)
System.out.println(new String("hi") == new String("hi")); // false!

5 == 5.0       # True (value equality)
5 is 5         # True (identity, small ints)
[1] == [1]     # True (value equality)
[1] is [1]     # False (different objects)
x is None      # idiomatic None check
1 < 2 < 3      # True (chained comparison)

println!("{}", 5 == 5);    // true
println!("{}", 5 != 3);    // true
println!("{}", 5 > 3);     // true
println!("{}", 5 <= 5);    // true
let a = (1, 2);
let b = (1, 2);
println!("{}", a == b);    // true (tuples are comparable)

5 === 5;              // true (strict equality)
5 !== "5";            // true (strict inequality)
5 == "5";             // avoid: loose equality with coercion
null == undefined;    // true (loose only)
null === undefined;   // false (strict)
NaN === NaN;          // false (use Number.isNaN)

std::cout << (true && false);    // 0
std::cout << (true || false);    // 1
std::cout << (!true);            // 0
if (x > 0 && x < 100) {
    std::cout << "in range\n";
}

fmt.Println(true && false)   // false
fmt.Println(true || false)   // true
fmt.Println(!true)           // false
if x > 0 && x < 100 {
    fmt.Println("in range")
}

System.out.println(true && false);    // false
System.out.println(true || false);    // true
System.out.println(!true);            // false
if (x > 0 && x < 100) {
    System.out.println("in range");
}

True and False       # False
True or False        # True
not True             # False
x = None or "default"    # "default"
y = "" or "fallback"     # "fallback" (falsy triggers or)

println!("{}", true && false);   // false
println!("{}", true || false);   // true
println!("{}", !true);           // false
if x > 0 && x < 100 {
    println!("in range");
}

true && false;             // false
true || false;             // true
!true;                     // false
let name: string | null = null;
let display = name ?? "Anonymous";  // nullish coalescing
let len = name?.length ?? 0;        // optional chaining

std::cout << (true && false);    // 0
std::cout << (true || false);    // 1
std::cout << (!true);            // 0
if (x > 0 && x < 100) {
    std::cout << "in range\n";
}

fmt.Println(true && false)   // false
fmt.Println(true || false)   // true
fmt.Println(!true)           // false
if x > 0 && x < 100 {
    fmt.Println("in range")
}

System.out.println(true && false);    // false
System.out.println(true || false);    // true
System.out.println(!true);            // false
if (x > 0 && x < 100) {
    System.out.println("in range");
}

True and False       # False
True or False        # True
not True             # False
x = None or "default"    # "default"
y = "" or "fallback"     # "fallback" (falsy triggers or)

println!("{}", true && false);   // false
println!("{}", true || false);   // true
println!("{}", !true);           // false
if x > 0 && x < 100 {
    println!("in range");
}

true && false;             // false
true || false;             // true
!true;                     // false
let name: string | null = null;
let display = name ?? "Anonymous";  // nullish coalescing
let len = name?.length ?? 0;        // optional chaining

int x = 10;
x += 5;     // 15
x -= 3;     // 12
x *= 2;     // 24
x /= 4;     // 6
x %= 5;     // 1
x++;         // 2 (also an expression, unlike Go)

x := 10
x += 5     // 15
x -= 3     // 12
x *= 2     // 24
x /= 4     // 6
x %= 5     // 1
x++        // 2 (statement, not expression)

int x = 10;
x += 5;     // 15
x -= 3;     // 12
x *= 2;     // 24
x /= 4;     // 6
x %= 5;     // 1
x++;         // 2

x = 10
x += 5     # 15
x -= 3     # 12
x *= 2     # 24
x //= 4    # 6
x %= 5     # 1
x **= 2    # 1

let mut x = 10;
x += 5;    // 15
x -= 3;    // 12
x *= 2;    // 24
x /= 4;    // 6
x %= 5;    // 1
x &= 0b11; // bitwise AND assign

let x = 10;
x += 5;     // 15
x -= 3;     // 12
x *= 2;     // 24
x /= 4;     // 6
x %= 5;     // 1
x **= 2;    // 1

int x = 10;
x += 5;     // 15
x -= 3;     // 12
x *= 2;     // 24
x /= 4;     // 6
x %= 5;     // 1
x++;         // 2 (also an expression, unlike Go)

x := 10
x += 5     // 15
x -= 3     // 12
x *= 2     // 24
x /= 4     // 6
x %= 5     // 1
x++        // 2 (statement, not expression)

int x = 10;
x += 5;     // 15
x -= 3;     // 12
x *= 2;     // 24
x /= 4;     // 6
x %= 5;     // 1
x++;         // 2

x = 10
x += 5     # 15
x -= 3     # 12
x *= 2     # 24
x //= 4    # 6
x %= 5     # 1
x **= 2    # 1

let mut x = 10;
x += 5;    // 15
x -= 3;    // 12
x *= 2;    // 24
x /= 4;    // 6
x %= 5;    // 1
x &= 0b11; // bitwise AND assign

let x = 10;
x += 5;     // 15
x -= 3;     // 12
x *= 2;     // 24
x /= 4;     // 6
x %= 5;     // 1
x **= 2;    // 1

Strings

typescript python

std::string greeting = "Hello";
std::string name = "World";
std::string combined = greeting + ", " + name + "!";
std::string empty;

greeting := "Hello"
name := "World"
combined := greeting + ", " + name + "!"
var empty string

String greeting = "Hello";
String name = "World";
String combined = greeting + ", " + name + "!";
String empty = "";

greeting = "Hello"
name = 'World'
combined = greeting + ", " + name + "!"
empty = ""

let greeting: &str = "Hello";
let name: String = String::from("World");
let combined = format!("{}, {}!", greeting, name);
let empty = String::new();

let greeting: string = "Hello";
let name: string = "World";
let combined: string = greeting + ", " + name + "!";
let empty: string = "";

std::string greeting = "Hello";
std::string name = "World";
std::string combined = greeting + ", " + name + "!";
std::string empty;

greeting := "Hello"
name := "World"
combined := greeting + ", " + name + "!"
var empty string

String greeting = "Hello";
String name = "World";
String combined = greeting + ", " + name + "!";
String empty = "";

greeting = "Hello"
name = 'World'
combined = greeting + ", " + name + "!"
empty = ""

let greeting: &str = "Hello";
let name: String = String::from("World");
let combined = format!("{}, {}!", greeting, name);
let empty = String::new();

let greeting: string = "Hello";
let name: string = "World";
let combined: string = greeting + ", " + name + "!";
let empty: string = "";

// C++ has no string interpolation — use std::format (C++20)
auto message = std::format("{}, {}!", greeting, name);
auto formatted = std::format("Age: {}, Score: {:.2f}", 25, 98.5);
auto expr = std::format("Sum: {}", 2 + 3);

message := fmt.Sprintf("%s, %s!", greeting, name)
formatted := fmt.Sprintf("Age: %d, Score: %.2f", 25, 98.5)
debug := fmt.Sprintf("Value: %v, Type: %T", 42, 42)

// Java has no string interpolation — use String.format or STR (preview)
String message = String.format("%s, %s!", greeting, name);
String formatted = String.format("Age: %d, Score: %.2f", 25, 98.5);
String expr = "Sum: " + (2 + 3);

message = f"{greeting}, {name}!"
formatted = f"Age: {25}, Score: {98.5:.2f}"
debug = f"Value: {42!r}, Type: {type(42).__name__}"

let message = format!("{}, {}!", greeting, name);
let formatted = format!("Age: {}, Score: {:.2}", 25, 98.5);
let debug = format!("Value: {:?}, Type: i32", 42);

let message = `${greeting}, ${name}!`;
let formatted = `Age: ${25}, Score: ${98.5.toFixed(2)}`;
let expr = `Sum: ${2 + 3}, Upper: ${"hi".toUpperCase()}`;

// C++ has no string interpolation — use std::format (C++20)
auto message = std::format("{}, {}!", greeting, name);
auto formatted = std::format("Age: {}, Score: {:.2f}", 25, 98.5);
auto expr = std::format("Sum: {}", 2 + 3);

message := fmt.Sprintf("%s, %s!", greeting, name)
formatted := fmt.Sprintf("Age: %d, Score: %.2f", 25, 98.5)
debug := fmt.Sprintf("Value: %v, Type: %T", 42, 42)

// Java has no string interpolation — use String.format or STR (preview)
String message = String.format("%s, %s!", greeting, name);
String formatted = String.format("Age: %d, Score: %.2f", 25, 98.5);
String expr = "Sum: " + (2 + 3);

message = f"{greeting}, {name}!"
formatted = f"Age: {25}, Score: {98.5:.2f}"
debug = f"Value: {42!r}, Type: {type(42).__name__}"

let message = format!("{}, {}!", greeting, name);
let formatted = format!("Age: {}, Score: {:.2}", 25, 98.5);
let debug = format!("Value: {:?}, Type: i32", 42);

let message = `${greeting}, ${name}!`;
let formatted = `Age: ${25}, Score: ${98.5.toFixed(2)}`;
let expr = `Sum: ${2 + 3}, Upper: ${"hi".toUpperCase()}`;

std::string text = "Hello, World!";
text.size();                               // 13
std::ranges::for_each(text, [](char& c){ c = std::toupper(c); });
text.find("World") != std::string::npos;   // true
text.starts_with("He");                    // true (C++20)
// replace first occurrence
text.replace(text.find("o"), 1, "0");

str := "Hello, World!"
len(str)                       // 13 (bytes)
strings.ToUpper(str)           // "HELLO, WORLD!"
strings.ToLower(str)           // "hello, world!"
strings.Contains(str, "World") // true
strings.HasPrefix(str, "He")   // true
strings.ReplaceAll(str, "o", "0")

String text = "Hello, World!";
text.length();                  // 13
text.toUpperCase();             // "HELLO, WORLD!"
text.toLowerCase();             // "hello, world!"
text.contains("World");         // true
text.startsWith("He");          // true
text.replace("o", "0");         // "Hell0, W0rld!" (all occurrences)

text = "Hello, World!"
len(text)                # 13
text.upper()             # "HELLO, WORLD!"
text.lower()             # "hello, world!"
"World" in text          # True
text.startswith("He")    # True
text.replace("o", "0")   # "Hell0, W0rld!"

let text = String::from("Hello, World!");
text.len();                    // 13 (bytes)
text.to_uppercase();           // "HELLO, WORLD!"
text.to_lowercase();           // "hello, world!"
text.contains("World");        // true
text.starts_with("He");        // true
text.replace("o", "0");        // "Hell0, W0rld!"

let text: string = "Hello, World!";
text.length;                // 13
text.toUpperCase();         // "HELLO, WORLD!"
text.toLowerCase();         // "hello, world!"
text.includes("World");     // true
text.startsWith("He");      // true
text.replace("o", "0");     // "Hell0, World!" (first only)
text.replaceAll("o", "0");  // "Hell0, W0rld!"

std::string text = "Hello, World!";
text.size();                               // 13
std::ranges::for_each(text, [](char& c){ c = std::toupper(c); });
text.find("World") != std::string::npos;   // true
text.starts_with("He");                    // true (C++20)
// replace first occurrence
text.replace(text.find("o"), 1, "0");

str := "Hello, World!"
len(str)                       // 13 (bytes)
strings.ToUpper(str)           // "HELLO, WORLD!"
strings.ToLower(str)           // "hello, world!"
strings.Contains(str, "World") // true
strings.HasPrefix(str, "He")   // true
strings.ReplaceAll(str, "o", "0")

String text = "Hello, World!";
text.length();                  // 13
text.toUpperCase();             // "HELLO, WORLD!"
text.toLowerCase();             // "hello, world!"
text.contains("World");         // true
text.startsWith("He");          // true
text.replace("o", "0");         // "Hell0, W0rld!" (all occurrences)

text = "Hello, World!"
len(text)                # 13
text.upper()             # "HELLO, WORLD!"
text.lower()             # "hello, world!"
"World" in text          # True
text.startswith("He")    # True
text.replace("o", "0")   # "Hell0, W0rld!"

let text = String::from("Hello, World!");
text.len();                    // 13 (bytes)
text.to_uppercase();           // "HELLO, WORLD!"
text.to_lowercase();           // "hello, world!"
text.contains("World");        // true
text.starts_with("He");        // true
text.replace("o", "0");        // "Hell0, W0rld!"

let text: string = "Hello, World!";
text.length;                // 13
text.toUpperCase();         // "HELLO, WORLD!"
text.toLowerCase();         // "hello, world!"
text.includes("World");     // true
text.startsWith("He");      // true
text.replace("o", "0");     // "Hell0, World!" (first only)
text.replaceAll("o", "0");  // "Hell0, W0rld!"

std::string text = "Hello, World!";
text.substr(0, 5);            // "Hello"
text.substr(7);               // "World!"
text.back();                  // '!'
std::string rev(text.rbegin(), text.rend());  // reversed

str := "Hello, World!"
str[0:5]                    // "Hello" (byte slicing)
chars := []rune(str)        // convert to Unicode code points
string(chars[7:12])         // "World" (safe for Unicode)
utf8.RuneCountInString(str) // 13 (character count)

String text = "Hello, World!";
text.substring(0, 5);           // "Hello"
text.substring(7);              // "World!"
text.charAt(text.length() - 1); // '!'
new StringBuilder(text).reverse().toString(); // reversed

text = "Hello, World!"
text[0:5]      # "Hello"
text[-6:]       # "orld!"
text[::2]       # "Hlo ol!"
text[::-1]      # "!dlroW ,olleH" (reverse)

let text = "Hello, World!";
&text[0..5];                       // "Hello" (byte index)
text.chars().count();              // 13 (character count)
let chars: Vec<char> = text.chars().collect();
let sub: String = chars[7..12].iter().collect();

let text = "Hello, World!";
text.slice(0, 5);           // "Hello"
text.slice(-6);             // "orld!"
text.at(-1);                // "!" (negative index)
[...text].reverse().join(""); // "!dlroW ,olleH"

std::string text = "Hello, World!";
text.substr(0, 5);            // "Hello"
text.substr(7);               // "World!"
text.back();                  // '!'
std::string rev(text.rbegin(), text.rend());  // reversed

str := "Hello, World!"
str[0:5]                    // "Hello" (byte slicing)
chars := []rune(str)        // convert to Unicode code points
string(chars[7:12])         // "World" (safe for Unicode)
utf8.RuneCountInString(str) // 13 (character count)

String text = "Hello, World!";
text.substring(0, 5);           // "Hello"
text.substring(7);              // "World!"
text.charAt(text.length() - 1); // '!'
new StringBuilder(text).reverse().toString(); // reversed

text = "Hello, World!"
text[0:5]      # "Hello"
text[-6:]       # "orld!"
text[::2]       # "Hlo ol!"
text[::-1]      # "!dlroW ,olleH" (reverse)

let text = "Hello, World!";
&text[0..5];                       // "Hello" (byte index)
text.chars().count();              // 13 (character count)
let chars: Vec<char> = text.chars().collect();
let sub: String = chars[7..12].iter().collect();

let text = "Hello, World!";
text.slice(0, 5);           // "Hello"
text.slice(-6);             // "orld!"
text.at(-1);                // "!" (negative index)
[...text].reverse().join(""); // "!dlroW ,olleH"

std::string multiline = "Line one\n"
    "Line two\n"
    "Line three";
auto raw = R"(C:\Users\name\file.txt)";
auto raw_delim = R"delim(She said "hello")delim";

multiline := `Line one
Line two
Line three`
raw := `C:\Users\name\file.txt`

String multiline = """
        Line one
        Line two
        Line three""";
String escaped = "C:\\Users\\name\\file.txt";

multiline = """Line one
Line two
Line three"""
raw = r"C:\Users\name\file.txt"

let multiline = "Line one\n\
    Line two\n\
    Line three";
let raw = r"C:\Users\name\file.txt";
let raw_hash = r#"She said "hello""#;

let multiline = `Line one
Line two
Line three`;
let escaped = "C:\\Users\\name\\file.txt";

std::string multiline = "Line one\n"
    "Line two\n"
    "Line three";
auto raw = R"(C:\Users\name\file.txt)";
auto raw_delim = R"delim(She said "hello")delim";

multiline := `Line one
Line two
Line three`
raw := `C:\Users\name\file.txt`

String multiline = """
        Line one
        Line two
        Line three""";
String escaped = "C:\\Users\\name\\file.txt";

multiline = """Line one
Line two
Line three"""
raw = r"C:\Users\name\file.txt"

let multiline = "Line one\n\
    Line two\n\
    Line three";
let raw = r"C:\Users\name\file.txt";
let raw_hash = r#"She said "hello""#;

let multiline = `Line one
Line two
Line three`;
let escaped = "C:\\Users\\name\\file.txt";

Conditionals

typescript python

if (score >= 90) {
    grade = "A";
} else {
    grade = "B";
}

if score >= 90 {
    grade = "A"
} else {
    grade = "B"
}

if (score >= 90) {
    grade = "A";
} else {
    grade = "B";
}

if score >= 90:
    grade = "A"
else:
    grade = "B"

let grade = if score >= 90 {
    "A"
} else {
    "B"
};

if (score >= 90) {
  grade = "A";
} else {
  grade = "B";
}

if (score >= 90) {
    grade = "A";
} else {
    grade = "B";
}

if score >= 90 {
    grade = "A"
} else {
    grade = "B"
}

if (score >= 90) {
    grade = "A";
} else {
    grade = "B";
}

if score >= 90:
    grade = "A"
else:
    grade = "B"

let grade = if score >= 90 {
    "A"
} else {
    "B"
};

if (score >= 90) {
  grade = "A";
} else {
  grade = "B";
}

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else {
    grade = "F";
}

if score := getScore(); score >= 90 {
    grade = "A"
} else if score >= 80 {
    grade = "B"
} else if score >= 70 {
    grade = "C"
} else {
    grade = "F"
}

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else {
    grade = "F";
}

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

let grade = if score >= 90 {
    "A"
} else if score >= 80 {
    "B"
} else if score >= 70 {
    "C"
} else {
    "F"
};

function describe(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else if (typeof value === "number") {
    return value.toFixed(2);
  } else {
    return String(value);
  }
}

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else {
    grade = "F";
}

if score := getScore(); score >= 90 {
    grade = "A"
} else if score >= 80 {
    grade = "B"
} else if score >= 70 {
    grade = "C"
} else {
    grade = "F"
}

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else {
    grade = "F";
}

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

let grade = if score >= 90 {
    "A"
} else if score >= 80 {
    "B"
} else if score >= 70 {
    "C"
} else {
    "F"
};

function describe(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else if (typeof value === "number") {
    return value.toFixed(2);
  } else {
    return String(value);
  }
}

std::string status = (age >= 18) ? "adult" : "minor";

// Go has no ternary operator — use a helper or if/else
func ternary(cond bool, a, b string) string {
    if cond {
        return a
    }
    return b
}
status := ternary(age >= 18, "adult", "minor")

String status = (age >= 18) ? "adult" : "minor";

status = "adult" if age >= 18 else "minor"

// if is already an expression, so no ternary needed
let status = if age >= 18 { "adult" } else { "minor" };

const status: string = age >= 18 ? "adult" : "minor";

std::string status = (age >= 18) ? "adult" : "minor";

// Go has no ternary operator — use a helper or if/else
func ternary(cond bool, a, b string) string {
    if cond {
        return a
    }
    return b
}
status := ternary(age >= 18, "adult", "minor")

String status = (age >= 18) ? "adult" : "minor";

status = "adult" if age >= 18 else "minor"

// if is already an expression, so no ternary needed
let status = if age >= 18 { "adult" } else { "minor" };

const status: string = age >= 18 ? "adult" : "minor";

switch (direction) {
case Direction::North:
    y += 1; break;
case Direction::South:
    y -= 1; break;
default:
    std::cout << "unknown direction\n";
}

// C++17: init-statement in if
if (auto it = m.find("key"); it != m.end()) {
    std::cout << it->second;
}

switch direction {
case "north":
    y += 1
case "south":
    y -= 1
default:
    fmt.Println("unknown direction")
}

switch {
case score >= 90:
    grade = "A"
case score >= 80:
    grade = "B"
default:
    grade = "C"
}

// switch expression (Java 14+)
String result = switch (direction) {
    case "north" -> "up";
    case "south" -> "down";
    default -> "unknown";
};

// pattern matching (Java 21+)
String describe(Object obj) {
    return switch (obj) {
        case Integer i -> "int: " + i;
        case String s  -> "str: " + s;
        default        -> "other";
    };
}

match direction:
    case "north":
        y += 1
    case "south":
        y -= 1
    case _:
        print("unknown direction")

let delta = match direction {
    "north" =>  (0,  1),
    "south" =>  (0, -1),
    "east"  =>  (1,  0),
    "west"  => (-1,  0),
    _       =>  (0,  0),
};

if let Some(value) = optional_value {
    println!("Got: {}", value);
}

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "rect"; w: number; h: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "rect":   return s.w * s.h;
  }
}

switch (direction) {
case Direction::North:
    y += 1; break;
case Direction::South:
    y -= 1; break;
default:
    std::cout << "unknown direction\n";
}

// C++17: init-statement in if
if (auto it = m.find("key"); it != m.end()) {
    std::cout << it->second;
}

switch direction {
case "north":
    y += 1
case "south":
    y -= 1
default:
    fmt.Println("unknown direction")
}

switch {
case score >= 90:
    grade = "A"
case score >= 80:
    grade = "B"
default:
    grade = "C"
}

// switch expression (Java 14+)
String result = switch (direction) {
    case "north" -> "up";
    case "south" -> "down";
    default -> "unknown";
};

// pattern matching (Java 21+)
String describe(Object obj) {
    return switch (obj) {
        case Integer i -> "int: " + i;
        case String s  -> "str: " + s;
        default        -> "other";
    };
}

match direction:
    case "north":
        y += 1
    case "south":
        y -= 1
    case _:
        print("unknown direction")

let delta = match direction {
    "north" =>  (0,  1),
    "south" =>  (0, -1),
    "east"  =>  (1,  0),
    "west"  => (-1,  0),
    _       =>  (0,  0),
};

if let Some(value) = optional_value {
    println!("Got: {}", value);
}

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "rect"; w: number; h: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "rect":   return s.w * s.h;
  }
}

Loops

typescript python

for (int i = 0; i < 5; i++) {
    std::cout << i << "\n";
}

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

for i in range(5):
    print(i)

for i in 0..5 {
    println!("{}", i);
}

for (let i = 0; i < 5; i++) {
  console.log(i);
}

for (int i = 0; i < 5; i++) {
    std::cout << i << "\n";
}

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

for i in range(5):
    print(i)

for i in 0..5 {
    println!("{}", i);
}

for (let i = 0; i < 5; i++) {
  console.log(i);
}

int i = 0;
while (i < 5) {
    std::cout << i << "\n";
    i++;
}

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

i = 0
while i < 5:
    print(i)
    i += 1

let mut i = 0;
while i < 5 {
    println!("{}", i);
    i += 1;
}

let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}

int i = 0;
while (i < 5) {
    std::cout << i << "\n";
    i++;
}

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

i = 0
while i < 5:
    print(i)
    i += 1

let mut i = 0;
while i < 5 {
    println!("{}", i);
    i += 1;
}

let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}

std::vector<int> nums = {10, 20, 30};
for (size_t i = 0; i < nums.size(); i++) {
    std::cout << i << ": " << nums[i] << "\n";
}

std::map<std::string, int> m = {{"a", 1}, {"b", 2}};
for (const auto& [key, val] : m) {
    std::cout << key << " = " << val << "\n";
}

nums := []int{10, 20, 30}
for index, value := range nums {
    fmt.Printf("%d: %d\n", index, value)
}

m := map[string]int{"a": 1, "b": 2}
for key, val := range m {
    fmt.Printf("%s = %d\n", key, val)
}

var nums = List.of(10, 20, 30);
for (int idx = 0; idx < nums.size(); idx++) {
    System.out.printf("%d: %d%n", idx, nums.get(idx));
}

var m = Map.of("a", 1, "b", 2);
for (var entry : m.entrySet()) {
    System.out.printf("%s = %d%n", entry.getKey(), entry.getValue());
}

nums = [10, 20, 30]
for index, value in enumerate(nums):
    print(f"{index}: {value}")

m = {"a": 1, "b": 2}
for key, val in m.items():
    print(f"{key} = {val}")

let nums = vec![10, 20, 30];
for (index, value) in nums.iter().enumerate() {
    println!("{}: {}", index, value);
}

let m = std::collections::HashMap::from([("a", 1), ("b", 2)]);
for (key, val) in &m {
    println!("{} = {}", key, val);
}

const nums = [10, 20, 30];
for (const [index, value] of nums.entries()) {
  console.log(`${index}: ${value}`);
}

const m = new Map([["a", 1], ["b", 2]]);
for (const [key, val] of m) {
  console.log(`${key} = ${val}`);
}

std::vector<int> nums = {10, 20, 30};
for (size_t i = 0; i < nums.size(); i++) {
    std::cout << i << ": " << nums[i] << "\n";
}

std::map<std::string, int> m = {{"a", 1}, {"b", 2}};
for (const auto& [key, val] : m) {
    std::cout << key << " = " << val << "\n";
}

nums := []int{10, 20, 30}
for index, value := range nums {
    fmt.Printf("%d: %d\n", index, value)
}

m := map[string]int{"a": 1, "b": 2}
for key, val := range m {
    fmt.Printf("%s = %d\n", key, val)
}

var nums = List.of(10, 20, 30);
for (int idx = 0; idx < nums.size(); idx++) {
    System.out.printf("%d: %d%n", idx, nums.get(idx));
}

var m = Map.of("a", 1, "b", 2);
for (var entry : m.entrySet()) {
    System.out.printf("%s = %d%n", entry.getKey(), entry.getValue());
}

nums = [10, 20, 30]
for index, value in enumerate(nums):
    print(f"{index}: {value}")

m = {"a": 1, "b": 2}
for key, val in m.items():
    print(f"{key} = {val}")

let nums = vec![10, 20, 30];
for (index, value) in nums.iter().enumerate() {
    println!("{}: {}", index, value);
}

let m = std::collections::HashMap::from([("a", 1), ("b", 2)]);
for (key, val) in &m {
    println!("{} = {}", key, val);
}

const nums = [10, 20, 30];
for (const [index, value] of nums.entries()) {
  console.log(`${index}: ${value}`);
}

const m = new Map([["a", 1], ["b", 2]]);
for (const [key, val] of m) {
  console.log(`${key} = ${val}`);
}

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        continue;
    }
    if (i == 7) {
        break;
    }
    std::cout << i << "\n";
}

for i := 0; i < 10; i++ {
    if i == 3 {
        continue
    }
    if i == 7 {
        break
    }
    fmt.Println(i)
}

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        continue;
    }
    if (i == 7) {
        break;
    }
    System.out.println(i);
}

for i in range(10):
    if i == 3:
        continue
    if i == 7:
        break
    print(i)

for i in 0..10 {
    if i == 3 {
        continue;
    }
    if i == 7 {
        break;
    }
    println!("{}", i);
}

for (let i = 0; i < 10; i++) {
  if (i === 3) {
    continue;
  }
  if (i === 7) {
    break;
  }
  console.log(i);
}

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        continue;
    }
    if (i == 7) {
        break;
    }
    std::cout << i << "\n";
}

for i := 0; i < 10; i++ {
    if i == 3 {
        continue
    }
    if i == 7 {
        break
    }
    fmt.Println(i)
}

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        continue;
    }
    if (i == 7) {
        break;
    }
    System.out.println(i);
}

for i in range(10):
    if i == 3:
        continue
    if i == 7:
        break
    print(i)

for i in 0..10 {
    if i == 3 {
        continue;
    }
    if i == 7 {
        break;
    }
    println!("{}", i);
}

for (let i = 0; i < 10; i++) {
  if (i === 3) {
    continue;
  }
  if (i === 7) {
    break;
  }
  console.log(i);
}

Functions

typescript python

std::string greet(const std::string& name) {
    return "Hello, " + name + "!";
}

func greet(name string) string {
    return "Hello, " + name + "!"
}

String greet(String name) {
    return "Hello, " + name + "!";
}

def greet(name):
    return f"Hello, {name}!"

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

function greet(name: string): string {
  return `Hello, ${name}!`;
}

const greetArrow = (name: string): string => `Hello, ${name}!`;

std::string greet(const std::string& name) {
    return "Hello, " + name + "!";
}

func greet(name string) string {
    return "Hello, " + name + "!"
}

String greet(String name) {
    return "Hello, " + name + "!";
}

def greet(name):
    return f"Hello, {name}!"

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

function greet(name: string): string {
  return `Hello, ${name}!`;
}

const greetArrow = (name: string): string => `Hello, ${name}!`;

int add(int a, int b) {
    return a + b;
}

std::string formatInfo(const std::string& name, int age, bool active) {
    return std::format("{} ({}) active={}", name, age, active);
}

func add(a, b int) int {
    return a + b
}

func format(name string, age int, active bool) string {
    return fmt.Sprintf("%s (%d) active=%t", name, age, active)
}

int add(int a, int b) {
    return a + b;
}

String formatInfo(String name, int age, boolean active) {
    return String.format("%s (%d) active=%b", name, age, active);
}

def add(a, b):
    return a + b

def format_info(name, age, active):
    return f"{name} ({age}) active={active}"

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn format_info(name: &str, age: u32, active: bool) -> String {
    format!("{} ({}) active={}", name, age, active)
}

function add(a: number, b: number): number {
  return a + b;
}

function formatInfo(name: string, age: number, active: boolean): string {
  return `${name} (${age}) active=${active}`;
}

int add(int a, int b) {
    return a + b;
}

std::string formatInfo(const std::string& name, int age, bool active) {
    return std::format("{} ({}) active={}", name, age, active);
}

func add(a, b int) int {
    return a + b
}

func format(name string, age int, active bool) string {
    return fmt.Sprintf("%s (%d) active=%t", name, age, active)
}

int add(int a, int b) {
    return a + b;
}

String formatInfo(String name, int age, boolean active) {
    return String.format("%s (%d) active=%b", name, age, active);
}

def add(a, b):
    return a + b

def format_info(name, age, active):
    return f"{name} ({age}) active={active}"

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn format_info(name: &str, age: u32, active: bool) -> String {
    format!("{} ({}) active={}", name, age, active)
}

function add(a: number, b: number): number {
  return a + b;
}

function formatInfo(name: string, age: number, active: boolean): string {
  return `${name} (${age}) active=${active}`;
}

void startServer(int port = 8080, bool verbose = false) {
    std::cout << "Starting on port " << port << "\n";
}

startServer();
startServer(3000, true);

// Go has no default parameters — use option structs
type Options struct {
    Port    int
    Verbose bool
}

func startServer(opts Options) {
    if opts.Port == 0 {
        opts.Port = 8080
    }
}

// Java has no default parameters — use overloading
void startServer() {
    startServer(8080, false);
}
void startServer(int port, boolean verbose) {
    System.out.println("Starting on port " + port);
}

startServer();
startServer(3000, true);

def start_server(port=8080, verbose=False):
    print(f"Starting on port {port}")

start_server()
start_server(port=3000, verbose=True)

// Rust has no default parameters — use the builder pattern
struct ServerConfig {
    port: u16,
    verbose: bool,
}

impl Default for ServerConfig {
    fn default() -> Self {
        Self { port: 8080, verbose: false }
    }
}

fn start_server(config: ServerConfig) { }
start_server(ServerConfig { port: 3000, ..Default::default() });

function startServer(port: number = 8080, verbose: boolean = false): void {
  console.log(`Starting on port ${port}`);
}

startServer();
startServer(3000, true);

void startServer(int port = 8080, bool verbose = false) {
    std::cout << "Starting on port " << port << "\n";
}

startServer();
startServer(3000, true);

// Go has no default parameters — use option structs
type Options struct {
    Port    int
    Verbose bool
}

func startServer(opts Options) {
    if opts.Port == 0 {
        opts.Port = 8080
    }
}

// Java has no default parameters — use overloading
void startServer() {
    startServer(8080, false);
}
void startServer(int port, boolean verbose) {
    System.out.println("Starting on port " + port);
}

startServer();
startServer(3000, true);

def start_server(port=8080, verbose=False):
    print(f"Starting on port {port}")

start_server()
start_server(port=3000, verbose=True)

// Rust has no default parameters — use the builder pattern
struct ServerConfig {
    port: u16,
    verbose: bool,
}

impl Default for ServerConfig {
    fn default() -> Self {
        Self { port: 8080, verbose: false }
    }
}

fn start_server(config: ServerConfig) { }
start_server(ServerConfig { port: 3000, ..Default::default() });

function startServer(port: number = 8080, verbose: boolean = false): void {
  console.log(`Starting on port ${port}`);
}

startServer();
startServer(3000, true);

std::pair<double, std::string> divide(double a, double b) {
    if (b == 0) {
        return {0, "division by zero"};
    }
    return {a / b, ""};
}
auto [result, err] = divide(10, 3);

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}
result, err := divide(10, 3)

// Java can only return one value — use a record (Java 16+)
record DivResult(double value, String error) {}

DivResult divide(double a, double b) {
    if (b == 0) {
        return new DivResult(0, "division by zero");
    }
    return new DivResult(a / b, null);
}
var result = divide(10, 3);

def divide(a, b):
    if b == 0:
        return None, "division by zero"
    return a / b, None

result, err = divide(10, 3)

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        return Err("division by zero".to_string());
    }
    Ok(a / b)
}
let result = divide(10.0, 3.0);

function divide(a: number, b: number): [number, string | null] {
  if (b === 0) {
    return [0, "division by zero"];
  }
  return [a / b, null];
}
const [result, err] = divide(10, 3);

std::pair<double, std::string> divide(double a, double b) {
    if (b == 0) {
        return {0, "division by zero"};
    }
    return {a / b, ""};
}
auto [result, err] = divide(10, 3);

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}
result, err := divide(10, 3)

// Java can only return one value — use a record (Java 16+)
record DivResult(double value, String error) {}

DivResult divide(double a, double b) {
    if (b == 0) {
        return new DivResult(0, "division by zero");
    }
    return new DivResult(a / b, null);
}
var result = divide(10, 3);

def divide(a, b):
    if b == 0:
        return None, "division by zero"
    return a / b, None

result, err = divide(10, 3)

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        return Err("division by zero".to_string());
    }
    Ok(a / b)
}
let result = divide(10.0, 3.0);

function divide(a: number, b: number): [number, string | null] {
  if (b === 0) {
    return [0, "division by zero"];
  }
  return [a / b, null];
}
const [result, err] = divide(10, 3);

// variadic template (type-safe)
template<typename... Args>
auto sum(Args... nums) {
    return (nums + ...);  // fold expression (C++17)
}
sum(1, 2, 3);

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3)
sum([]int{1, 2, 3}...)

int sum(int... nums) {
    return java.util.Arrays.stream(nums).sum();
}
sum(1, 2, 3);

def total(*nums):
    return sum(nums)

total(1, 2, 3)

def config(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")
config(port=8080, debug=True)

// Rust has no variadic functions — use macros or slices
fn sum(nums: &[i32]) -> i32 {
    nums.iter().sum()
}
sum(&[1, 2, 3]);

// or use a macro for variadic-like syntax
macro_rules! sum {
    ($($n:expr),*) => {{ [$($n),*].iter().sum::<i32>() }};
}
let total = sum!(1, 2, 3);

function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3);

// variadic template (type-safe)
template<typename... Args>
auto sum(Args... nums) {
    return (nums + ...);  // fold expression (C++17)
}
sum(1, 2, 3);

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3)
sum([]int{1, 2, 3}...)

int sum(int... nums) {
    return java.util.Arrays.stream(nums).sum();
}
sum(1, 2, 3);

def total(*nums):
    return sum(nums)

total(1, 2, 3)

def config(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")
config(port=8080, debug=True)

// Rust has no variadic functions — use macros or slices
fn sum(nums: &[i32]) -> i32 {
    nums.iter().sum()
}
sum(&[1, 2, 3]);

// or use a macro for variadic-like syntax
macro_rules! sum {
    ($($n:expr),*) => {{ [$($n),*].iter().sum::<i32>() }};
}
let total = sum!(1, 2, 3);

function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3);

Closures

typescript python

auto add = [](int a, int b) { return a + b; };
std::cout << add(2, 3) << "\n";

auto greet = [](const std::string& name) {
    return "Hello, " + name + "!";
};

add := func(a, b int) int { return a + b }
fmt.Println(add(2, 3))

func(msg string) {
    fmt.Println(msg)
}("hello")

IntBinaryOperator add = (a, b) -> a + b;
System.out.println(add.applyAsInt(2, 3));

Function<String, String> greet = name -> "Hello, " + name + "!";

add = lambda a, b: a + b
print(add(2, 3))

greet = lambda name: f"Hello, {name}!"

let add = |a: i32, b: i32| -> i32 { a + b };
println!("{}", add(2, 3));

let greet = |name: &str| format!("Hello, {}!", name);

const add = (a: number, b: number): number => a + b;
console.log(add(2, 3));

const greet = (name: string): string => `Hello, ${name}!`;

auto add = [](int a, int b) { return a + b; };
std::cout << add(2, 3) << "\n";

auto greet = [](const std::string& name) {
    return "Hello, " + name + "!";
};

add := func(a, b int) int { return a + b }
fmt.Println(add(2, 3))

func(msg string) {
    fmt.Println(msg)
}("hello")

IntBinaryOperator add = (a, b) -> a + b;
System.out.println(add.applyAsInt(2, 3));

Function<String, String> greet = name -> "Hello, " + name + "!";

add = lambda a, b: a + b
print(add(2, 3))

greet = lambda name: f"Hello, {name}!"

let add = |a: i32, b: i32| -> i32 { a + b };
println!("{}", add(2, 3));

let greet = |name: &str| format!("Hello, {}!", name);

const add = (a: number, b: number): number => a + b;
console.log(add(2, 3));

const greet = (name: string): string => `Hello, ${name}!`;

auto makeCounter() {
    int count = 0;
    return [count]() mutable -> int {
        return ++count;
    };
}

auto counter = makeCounter();
std::cout << counter() << "\n"; // 1
std::cout << counter() << "\n"; // 2

func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
counter := makeCounter()
fmt.Println(counter()) // 1
fmt.Println(counter()) // 2

static Supplier<Integer> makeCounter() {
    int[] count = {0};  // effectively final array trick
    return () -> ++count[0];
}

var counter = makeCounter();
System.out.println(counter.get()); // 1
System.out.println(counter.get()); // 2

def make_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

counter = make_counter()
print(counter())  # 1
print(counter())  # 2

fn make_counter() -> impl FnMut() -> i32 {
    let mut count = 0;
    move || {
        count += 1;
        count
    }
}
let mut counter = make_counter();
println!("{}", counter()); // 1
println!("{}", counter()); // 2

const makeCounter = (): (() => number) => {
  let count = 0;
  return () => ++count;
};

const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2

auto makeCounter() {
    int count = 0;
    return [count]() mutable -> int {
        return ++count;
    };
}

auto counter = makeCounter();
std::cout << counter() << "\n"; // 1
std::cout << counter() << "\n"; // 2

func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
counter := makeCounter()
fmt.Println(counter()) // 1
fmt.Println(counter()) // 2

static Supplier<Integer> makeCounter() {
    int[] count = {0};  // effectively final array trick
    return () -> ++count[0];
}

var counter = makeCounter();
System.out.println(counter.get()); // 1
System.out.println(counter.get()); // 2

def make_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

counter = make_counter()
print(counter())  # 1
print(counter())  # 2

fn make_counter() -> impl FnMut() -> i32 {
    let mut count = 0;
    move || {
        count += 1;
        count
    }
}
let mut counter = make_counter();
println!("{}", counter()); // 1
println!("{}", counter()); // 2

const makeCounter = (): (() => number) => {
  let count = 0;
  return () => ++count;
};

const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2

int total = 0;
auto addTo = [&total](int n) {
    total += n;
};
addTo(5);
addTo(3);
std::cout << total << "\n"; // 8

// capture by value vs reference
int x = 10;
auto byVal = [x]() { return x; };      // copy of x
auto byRef = [&x]() { return x; };     // reference to x

total := 0
addTo := func(n int) {
    total += n
}
addTo(5)
addTo(3)
fmt.Println(total) // 8

// goroutine pitfall — capture by argument
for i := 0; i < 3; i++ {
    go func(n int) {
        fmt.Println(n)
    }(i)
}

// captured variables must be effectively final
int[] total = {0};  // use array to work around restriction
IntConsumer addTo = n -> total[0] += n;
addTo.accept(5);
addTo.accept(3);
System.out.println(total[0]); // 8

// AtomicInteger for thread-safe mutation
var counter = new AtomicInteger(0);
Runnable inc = counter::incrementAndGet;

def make_accumulator():
    total = 0
    def add(n):
        nonlocal total
        total += n
        return total
    return add

acc = make_accumulator()
acc(5)
print(acc(3))  # 8

# loop capture pitfall — use default arg
funcs = [lambda x, i=i: x + i for i in range(3)]
print(funcs[1](10))  # 11

let mut total = 0;
let mut add_to = |n: i32| {
    total += n;
};
add_to(5);
add_to(3);
drop(add_to);
println!("{}", total); // 8

// move closure transfers ownership
let name = String::from("Alice");
let greet = move || println!("Hello, {}!", name);
greet();
// name is no longer accessible here

let total = 0;
const addTo = (n: number): void => {
  total += n;
};
addTo(5);
addTo(3);
console.log(total); // 8

// loop capture — let gives block scope (no pitfall)
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0); // 0, 1, 2
}

int total = 0;
auto addTo = [&total](int n) {
    total += n;
};
addTo(5);
addTo(3);
std::cout << total << "\n"; // 8

// capture by value vs reference
int x = 10;
auto byVal = [x]() { return x; };      // copy of x
auto byRef = [&x]() { return x; };     // reference to x

total := 0
addTo := func(n int) {
    total += n
}
addTo(5)
addTo(3)
fmt.Println(total) // 8

// goroutine pitfall — capture by argument
for i := 0; i < 3; i++ {
    go func(n int) {
        fmt.Println(n)
    }(i)
}

// captured variables must be effectively final
int[] total = {0};  // use array to work around restriction
IntConsumer addTo = n -> total[0] += n;
addTo.accept(5);
addTo.accept(3);
System.out.println(total[0]); // 8

// AtomicInteger for thread-safe mutation
var counter = new AtomicInteger(0);
Runnable inc = counter::incrementAndGet;

def make_accumulator():
    total = 0
    def add(n):
        nonlocal total
        total += n
        return total
    return add

acc = make_accumulator()
acc(5)
print(acc(3))  # 8

# loop capture pitfall — use default arg
funcs = [lambda x, i=i: x + i for i in range(3)]
print(funcs[1](10))  # 11

let mut total = 0;
let mut add_to = |n: i32| {
    total += n;
};
add_to(5);
add_to(3);
drop(add_to);
println!("{}", total); // 8

// move closure transfers ownership
let name = String::from("Alice");
let greet = move || println!("Hello, {}!", name);
greet();
// name is no longer accessible here

let total = 0;
const addTo = (n: number): void => {
  total += n;
};
addTo(5);
addTo(3);
console.log(total); // 8

// loop capture — let gives block scope (no pitfall)
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0); // 0, 1, 2
}

std::vector<int> nums = {1, 2, 3, 4, 5};
std::vector<int> doubled(nums.size());
std::ranges::transform(nums, doubled.begin(), [](int n) { return n * 2; });

int threshold = 3;
std::vector<int> above;
std::ranges::copy_if(nums, std::back_inserter(above),
    [threshold](int n) { return n > threshold; });

func apply(nums []int, fn func(int) int) []int {
    result := make([]int, len(nums))
    for i, n := range nums {
        result[i] = fn(n)
    }
    return result
}
doubled := apply([]int{1, 2, 3}, func(n int) int { return n * 2 })

var nums = List.of(1, 2, 3, 4, 5);
var doubled = nums.stream().map(n -> n * 2).toList();

int threshold = 3;
var above = nums.stream().filter(n -> n > threshold).toList();

nums = [1, 2, 3, 4, 5]
doubled = list(map(lambda n: n * 2, nums))

threshold = 3
above = list(filter(lambda n: n > threshold, nums))

let nums = vec![1, 2, 3, 4, 5];
let doubled: Vec<_> = nums.iter().map(|n| n * 2).collect();

let threshold = 3;
let above: Vec<_> = nums.iter().filter(|&&n| n > threshold).collect();

const nums: number[] = [1, 2, 3, 4, 5];
const doubled = nums.map((n) => n * 2);

const threshold = 3;
const above = nums.filter((n) => n > threshold);

type Callback<T> = (data: T) => void;
function onData<T>(url: string, cb: Callback<T>): void { }

std::vector<int> nums = {1, 2, 3, 4, 5};
std::vector<int> doubled(nums.size());
std::ranges::transform(nums, doubled.begin(), [](int n) { return n * 2; });

int threshold = 3;
std::vector<int> above;
std::ranges::copy_if(nums, std::back_inserter(above),
    [threshold](int n) { return n > threshold; });

func apply(nums []int, fn func(int) int) []int {
    result := make([]int, len(nums))
    for i, n := range nums {
        result[i] = fn(n)
    }
    return result
}
doubled := apply([]int{1, 2, 3}, func(n int) int { return n * 2 })

var nums = List.of(1, 2, 3, 4, 5);
var doubled = nums.stream().map(n -> n * 2).toList();

int threshold = 3;
var above = nums.stream().filter(n -> n > threshold).toList();

nums = [1, 2, 3, 4, 5]
doubled = list(map(lambda n: n * 2, nums))

threshold = 3
above = list(filter(lambda n: n > threshold, nums))

let nums = vec![1, 2, 3, 4, 5];
let doubled: Vec<_> = nums.iter().map(|n| n * 2).collect();

let threshold = 3;
let above: Vec<_> = nums.iter().filter(|&&n| n > threshold).collect();

const nums: number[] = [1, 2, 3, 4, 5];
const doubled = nums.map((n) => n * 2);

const threshold = 3;
const above = nums.filter((n) => n > threshold);

type Callback<T> = (data: T) => void;
function onData<T>(url: string, cb: Callback<T>): void { }

Modules & Imports

typescript python

// math.h — header file declares the public API
#pragma once
namespace math {
    int add(int a, int b);
}

// math.cpp — implementation file
#include "math.h"
namespace math {
    int add(int a, int b) { return a + b; }
    static void helper() {}  // file-local (not exported)
}

// every file starts with a package declaration
package mathutils

// exported function (uppercase = public)
func Add(a, b int) int { return a + b }

// unexported function (lowercase = package-private)
func helper() {}

// src/com/example/math/MathUtils.java
package com.example.math;

public class MathUtils {
    public static int add(int a, int b) { return a + b; }
    private static void helper() {}  // private = class-only
}

# mathutils.py — a module is just a .py file
def add(a, b):
    return a + b

def _helper():
    pass  # underscore convention = private

# package structure
# mypackage/
#   __init__.py
#   core.py
#   utils.py

// in lib.rs or main.rs — declare modules
mod math;       // loads from math.rs or math/mod.rs
pub mod utils;  // public module

// math.rs — define items in the module
pub fn add(a: i32, b: i32) -> i32 { a + b }
fn helper() {}  // private by default

// math.ts — each file is a module
export function add(a: number, b: number): number {
  return a + b;
}

export interface Config {
  debug: boolean;
  port: number;
}

function helper(): void {}  // not exported = private

// math.h — header file declares the public API
#pragma once
namespace math {
    int add(int a, int b);
}

// math.cpp — implementation file
#include "math.h"
namespace math {
    int add(int a, int b) { return a + b; }
    static void helper() {}  // file-local (not exported)
}

// every file starts with a package declaration
package mathutils

// exported function (uppercase = public)
func Add(a, b int) int { return a + b }

// unexported function (lowercase = package-private)
func helper() {}

// src/com/example/math/MathUtils.java
package com.example.math;

public class MathUtils {
    public static int add(int a, int b) { return a + b; }
    private static void helper() {}  // private = class-only
}

# mathutils.py — a module is just a .py file
def add(a, b):
    return a + b

def _helper():
    pass  # underscore convention = private

# package structure
# mypackage/
#   __init__.py
#   core.py
#   utils.py

// in lib.rs or main.rs — declare modules
mod math;       // loads from math.rs or math/mod.rs
pub mod utils;  // public module

// math.rs — define items in the module
pub fn add(a: i32, b: i32) -> i32 { a + b }
fn helper() {}  // private by default

// math.ts — each file is a module
export function add(a: number, b: number): number {
  return a + b;
}

export interface Config {
  debug: boolean;
  port: number;
}

function helper(): void {}  // not exported = private

#include "math.h"               // project header
#include <iostream>              // standard library
#include <vector>               // standard library

using std::cout;                // bring specific name into scope
using namespace std::literals;  // for "hello"s string literals

import (
    "fmt"
    "math"
    "github.com/user/project/internal/utils"
)

func main() {
    fmt.Println(math.Sqrt(16))
    utils.Format("hello")
}

import com.example.math.MathUtils;
import java.util.List;
import java.util.Map;
import static java.lang.Math.sqrt;

double result = sqrt(16);

import math
print(math.sqrt(16))

from os.path import join, exists

# relative import (inside a package)
from . import utils
from ..helpers import format_name

use crate::math::add;
use std::collections::HashMap;
use std::io::{self, Read, Write};

import { add } from "./math";
import type { Config } from "./config";
import * as utils from "./utils";

#include "math.h"               // project header
#include <iostream>              // standard library
#include <vector>               // standard library

using std::cout;                // bring specific name into scope
using namespace std::literals;  // for "hello"s string literals

import (
    "fmt"
    "math"
    "github.com/user/project/internal/utils"
)

func main() {
    fmt.Println(math.Sqrt(16))
    utils.Format("hello")
}

import com.example.math.MathUtils;
import java.util.List;
import java.util.Map;
import static java.lang.Math.sqrt;

double result = sqrt(16);

import math
print(math.sqrt(16))

from os.path import join, exists

# relative import (inside a package)
from . import utils
from ..helpers import format_name

use crate::math::add;
use std::collections::HashMap;
use std::io::{self, Read, Write};

import { add } from "./math";
import type { Config } from "./config";
import * as utils from "./utils";

// api.h — umbrella header for clean public API
#pragma once
#include "math.h"
#include "utils.h"
#include "config.h"

// Go has no re-exporting — expose via wrapper functions
package api

import "github.com/user/project/internal/core"

func Process(data string) string {
    return core.Process(data)
}

// Java has no re-exporting — use a facade class
package com.example.api;

import com.example.internal.Core;
import com.example.internal.Utils;

public class Api {
    public static String process(String data) { return Core.process(data); }
    public static String formatName(String n) { return Utils.formatName(n); }
}

# mypackage/__init__.py — controls the public API
from .core import process
from .utils import format_name

__all__ = ["process", "format_name"]

// lib.rs — re-export items for a clean public API
mod internal;

pub use internal::process;
pub use internal::utils::format_name;

// index.ts — barrel file for clean public API
export { add } from "./math";
export type { Config } from "./config";
export * from "./utils";

// api.h — umbrella header for clean public API
#pragma once
#include "math.h"
#include "utils.h"
#include "config.h"

// Go has no re-exporting — expose via wrapper functions
package api

import "github.com/user/project/internal/core"

func Process(data string) string {
    return core.Process(data)
}

// Java has no re-exporting — use a facade class
package com.example.api;

import com.example.internal.Core;
import com.example.internal.Utils;

public class Api {
    public static String process(String data) { return Core.process(data); }
    public static String formatName(String n) { return Utils.formatName(n); }
}

# mypackage/__init__.py — controls the public API
from .core import process
from .utils import format_name

__all__ = ["process", "format_name"]

// lib.rs — re-export items for a clean public API
mod internal;

pub use internal::process;
pub use internal::utils::format_name;

// index.ts — barrel file for clean public API
export { add } from "./math";
export type { Config } from "./config";
export * from "./utils";

// public — declared in header file
void startServer();
extern const int MAX_RETRIES;

// private — static or anonymous namespace
static void loadConfig() {}
namespace {
    void internalHelper() {}
}

class Server {
public:
    int port;
private:
    std::string key;
protected:
    std::string name;
};

package server

// public — accessible from other packages
func StartServer() {}
var MaxRetries = 3
type Config struct {
    Port int    // exported field
    key  string // unexported field
}

// private — only within this package
func loadConfig() Config { return Config{} }

// public — accessible from anywhere
public class Server {
    public int port;
    public static final int MAX_RETRIES = 3;

    private String key;       // class-only
    protected String name;    // class + subclasses + package
    String host;              // package-private (default)
}

# public
def start_server():
    pass

MAX_RETRIES = 3

# private by convention (single underscore)
def _load_config():
    pass

# name-mangled (double underscore, class only)
class Server:
    def __init__(self):
        self.__secret = "key"

pub fn start_server() {}
pub const MAX_RETRIES: u32 = 3;

pub struct Config {
    pub port: u16,           // public field
    pub(crate) key: String,  // visible within crate only
}

fn load_config() -> Config {
    Config { port: 8080, key: "secret".into() }
}

// module-level: export = public, no export = private
export function startServer(): void {}
export const MAX_RETRIES = 3;

function loadConfig(): Config {
  return { debug: false, port: 8080 };
}

// class-level visibility
class Server {
  public port: number;
  private key: string;
  protected name: string;
}

// public — declared in header file
void startServer();
extern const int MAX_RETRIES;

// private — static or anonymous namespace
static void loadConfig() {}
namespace {
    void internalHelper() {}
}

class Server {
public:
    int port;
private:
    std::string key;
protected:
    std::string name;
};

package server

// public — accessible from other packages
func StartServer() {}
var MaxRetries = 3
type Config struct {
    Port int    // exported field
    key  string // unexported field
}

// private — only within this package
func loadConfig() Config { return Config{} }

// public — accessible from anywhere
public class Server {
    public int port;
    public static final int MAX_RETRIES = 3;

    private String key;       // class-only
    protected String name;    // class + subclasses + package
    String host;              // package-private (default)
}

# public
def start_server():
    pass

MAX_RETRIES = 3

# private by convention (single underscore)
def _load_config():
    pass

# name-mangled (double underscore, class only)
class Server:
    def __init__(self):
        self.__secret = "key"

pub fn start_server() {}
pub const MAX_RETRIES: u32 = 3;

pub struct Config {
    pub port: u16,           // public field
    pub(crate) key: String,  // visible within crate only
}

fn load_config() -> Config {
    Config { port: 8080, key: "secret".into() }
}

// module-level: export = public, no export = private
export function startServer(): void {}
export const MAX_RETRIES = 3;

function loadConfig(): Config {
  return { debug: false, port: 8080 };
}

// class-level visibility
class Server {
  public port: number;
  private key: string;
  protected name: string;
}

Arrays / Lists

typescript python

std::vector<int> nums = {1, 2, 3, 4, 5};
std::vector<int> empty;
empty.reserve(10);
std::vector<std::string> names = {"alice", "bob", "carol"};

nums := []int{1, 2, 3, 4, 5}
empty := make([]int, 0, 10)
names := []string{"alice", "bob", "carol"}

var nums = new ArrayList<>(List.of(1, 2, 3, 4, 5));
var empty = new ArrayList<Integer>();
var names = new ArrayList<>(List.of("alice", "bob", "carol"));

nums = [1, 2, 3, 4, 5]
empty: list[int] = []
names = ["alice", "bob", "carol"]

let nums: Vec<i32> = vec![1, 2, 3, 4, 5];
let empty: Vec<i32> = Vec::with_capacity(10);
let names = vec!["alice", "bob", "carol"];

const nums: number[] = [1, 2, 3, 4, 5];
const empty: number[] = [];
const names: string[] = ["alice", "bob", "carol"];

std::vector<int> nums = {1, 2, 3, 4, 5};
std::vector<int> empty;
empty.reserve(10);
std::vector<std::string> names = {"alice", "bob", "carol"};

nums := []int{1, 2, 3, 4, 5}
empty := make([]int, 0, 10)
names := []string{"alice", "bob", "carol"}

var nums = new ArrayList<>(List.of(1, 2, 3, 4, 5));
var empty = new ArrayList<Integer>();
var names = new ArrayList<>(List.of("alice", "bob", "carol"));

nums = [1, 2, 3, 4, 5]
empty: list[int] = []
names = ["alice", "bob", "carol"]

let nums: Vec<i32> = vec![1, 2, 3, 4, 5];
let empty: Vec<i32> = Vec::with_capacity(10);
let names = vec!["alice", "bob", "carol"];

const nums: number[] = [1, 2, 3, 4, 5];
const empty: number[] = [];
const names: string[] = ["alice", "bob", "carol"];

int first = nums[0];
int last = nums.back();
nums[2] = 30;
int safe = nums.at(0);  // bounds-checked, throws on out of range

first := nums[0]
last := nums[len(nums)-1]
nums[2] = 30

int first = nums.get(0);
int last = nums.get(nums.size() - 1);
nums.set(2, 30);

first = nums[0]
last = nums[-1]
nums[2] = 30

let first = nums[0];
let last = nums[nums.len() - 1];
let mut nums = nums;
nums[2] = 30;

const first = nums[0];
const last = nums[nums.length - 1];
nums[2] = 30;

int first = nums[0];
int last = nums.back();
nums[2] = 30;
int safe = nums.at(0);  // bounds-checked, throws on out of range

first := nums[0]
last := nums[len(nums)-1]
nums[2] = 30

int first = nums.get(0);
int last = nums.get(nums.size() - 1);
nums.set(2, 30);

first = nums[0]
last = nums[-1]
nums[2] = 30

let first = nums[0];
let last = nums[nums.len() - 1];
let mut nums = nums;
nums[2] = 30;

const first = nums[0];
const last = nums[nums.length - 1];
nums[2] = 30;

std::vector<int> middle(nums.begin() + 1, nums.begin() + 4);
std::vector<int> fromStart(nums.begin(), nums.begin() + 3);
std::vector<int> toEnd(nums.begin() + 2, nums.end());
std::vector<int> copied = nums;

middle := nums[1:4]
fromStart := nums[:3]
toEnd := nums[2:]
copied := make([]int, len(nums))
copy(copied, nums)

var middle = new ArrayList<>(nums.subList(1, 4));
var fromStart = new ArrayList<>(nums.subList(0, 3));
var toEnd = new ArrayList<>(nums.subList(2, nums.size()));
var copied = new ArrayList<>(nums);

middle = nums[1:4]
from_start = nums[:3]
to_end = nums[2:]
copied = nums[:]
reversed_list = nums[::-1]

let middle: &[i32] = &nums[1..4];
let from_start: &[i32] = &nums[..3];
let to_end: &[i32] = &nums[2..];
let copied = nums.clone();

const middle = nums.slice(1, 4);
const fromStart = nums.slice(0, 3);
const toEnd = nums.slice(2);
const copied = [...nums];

std::vector<int> middle(nums.begin() + 1, nums.begin() + 4);
std::vector<int> fromStart(nums.begin(), nums.begin() + 3);
std::vector<int> toEnd(nums.begin() + 2, nums.end());
std::vector<int> copied = nums;

middle := nums[1:4]
fromStart := nums[:3]
toEnd := nums[2:]
copied := make([]int, len(nums))
copy(copied, nums)

var middle = new ArrayList<>(nums.subList(1, 4));
var fromStart = new ArrayList<>(nums.subList(0, 3));
var toEnd = new ArrayList<>(nums.subList(2, nums.size()));
var copied = new ArrayList<>(nums);

middle = nums[1:4]
from_start = nums[:3]
to_end = nums[2:]
copied = nums[:]
reversed_list = nums[::-1]

let middle: &[i32] = &nums[1..4];
let from_start: &[i32] = &nums[..3];
let to_end: &[i32] = &nums[2..];
let copied = nums.clone();

const middle = nums.slice(1, 4);
const fromStart = nums.slice(0, 3);
const toEnd = nums.slice(2);
const copied = [...nums];

for (size_t i = 0; i < nums.size(); i++) {
    std::cout << i << " " << nums[i] << "\n";
}
std::vector<int> doubled(nums.size());
std::ranges::transform(nums, doubled.begin(), [](int n) { return n * 2; });

for i, n := range nums {
    fmt.Println(i, n)
}
doubled := make([]int, len(nums))
for i, n := range nums {
    doubled[i] = n * 2
}

for (int i = 0; i < nums.size(); i++) {
    System.out.println(i + " " + nums.get(i));
}
var doubled = nums.stream().map(n -> n * 2).toList();
var evens = nums.stream().filter(n -> n % 2 == 0).toList();

for i, n in enumerate(nums):
    print(i, n)
doubled = [n * 2 for n in nums]
evens = [n for n in nums if n % 2 == 0]

for (i, n) in nums.iter().enumerate() {
    println!("{i}: {n}");
}
let doubled: Vec<i32> = nums.iter().map(|n| n * 2).collect();
let evens: Vec<i32> = nums.iter().filter(|n| **n % 2 == 0).cloned().collect();

nums.forEach((n, i) => {
    console.log(i, n);
});
const doubled = nums.map(n => n * 2);
const evens = nums.filter(n => n % 2 === 0);

for (size_t i = 0; i < nums.size(); i++) {
    std::cout << i << " " << nums[i] << "\n";
}
std::vector<int> doubled(nums.size());
std::ranges::transform(nums, doubled.begin(), [](int n) { return n * 2; });

for i, n := range nums {
    fmt.Println(i, n)
}
doubled := make([]int, len(nums))
for i, n := range nums {
    doubled[i] = n * 2
}

for (int i = 0; i < nums.size(); i++) {
    System.out.println(i + " " + nums.get(i));
}
var doubled = nums.stream().map(n -> n * 2).toList();
var evens = nums.stream().filter(n -> n % 2 == 0).toList();

for i, n in enumerate(nums):
    print(i, n)
doubled = [n * 2 for n in nums]
evens = [n for n in nums if n % 2 == 0]

for (i, n) in nums.iter().enumerate() {
    println!("{i}: {n}");
}
let doubled: Vec<i32> = nums.iter().map(|n| n * 2).collect();
let evens: Vec<i32> = nums.iter().filter(|n| **n % 2 == 0).cloned().collect();

nums.forEach((n, i) => {
    console.log(i, n);
});
const doubled = nums.map(n => n * 2);
const evens = nums.filter(n => n % 2 === 0);

nums.push_back(6);
nums.insert(nums.end(), {7, 8, 9});
std::vector<int> combined;
combined.insert(combined.end(), nums.begin(), nums.end());
auto length = nums.size();
std::ranges::sort(nums);

nums = append(nums, 6)
nums = append(nums, 7, 8, 9)
combined := append(nums, names...)
length := len(nums)
sort.Ints(nums)

nums.add(6);
nums.addAll(List.of(7, 8, 9));
var combined = new ArrayList<>(nums);
combined.addAll(names);
int length = nums.size();
Collections.sort(nums);

nums.append(6)
nums.extend([7, 8, 9])
combined = nums + names
length = len(nums)
nums.sort()

nums.push(6);
nums.extend([7, 8, 9]);
let combined = [nums.clone(), names_i32].concat();
let length = nums.len();
nums.sort();

nums.push(6);
nums.push(7, 8, 9);
const combined = [...nums, ...names];
const length = nums.length;
nums.sort((a, b) => a - b);

nums.push_back(6);
nums.insert(nums.end(), {7, 8, 9});
std::vector<int> combined;
combined.insert(combined.end(), nums.begin(), nums.end());
auto length = nums.size();
std::ranges::sort(nums);

nums = append(nums, 6)
nums = append(nums, 7, 8, 9)
combined := append(nums, names...)
length := len(nums)
sort.Ints(nums)

nums.add(6);
nums.addAll(List.of(7, 8, 9));
var combined = new ArrayList<>(nums);
combined.addAll(names);
int length = nums.size();
Collections.sort(nums);

nums.append(6)
nums.extend([7, 8, 9])
combined = nums + names
length = len(nums)
nums.sort()

nums.push(6);
nums.extend([7, 8, 9]);
let combined = [nums.clone(), names_i32].concat();
let length = nums.len();
nums.sort();

nums.push(6);
nums.push(7, 8, 9);
const combined = [...nums, ...names];
const length = nums.length;
nums.sort((a, b) => a - b);

Maps / Dicts

typescript python

std::unordered_map<std::string, std::string> user = {
    {"name", "Alice"},
    {"city", "NYC"},
};
std::unordered_map<std::string, int> counts;

user := map[string]string{
    "name": "Alice",
    "city": "NYC",
}
counts := make(map[string]int)

var user = new HashMap<>(Map.of(
    "name", "Alice",
    "city", "NYC"
));
var counts = new HashMap<String, Integer>();

user = {"name": "Alice", "city": "NYC"}
counts: dict[str, int] = {}
from_pairs = dict([("a", 1), ("b", 2)])

use std::collections::HashMap;
let mut user = HashMap::new();
user.insert("name", "Alice");
user.insert("city", "NYC");

const user: Record<string, string> = {
    name: "Alice",
    city: "NYC",
};
const counts = new Map<string, number>();

std::unordered_map<std::string, std::string> user = {
    {"name", "Alice"},
    {"city", "NYC"},
};
std::unordered_map<std::string, int> counts;

user := map[string]string{
    "name": "Alice",
    "city": "NYC",
}
counts := make(map[string]int)

var user = new HashMap<>(Map.of(
    "name", "Alice",
    "city", "NYC"
));
var counts = new HashMap<String, Integer>();

user = {"name": "Alice", "city": "NYC"}
counts: dict[str, int] = {}
from_pairs = dict([("a", 1), ("b", 2)])

use std::collections::HashMap;
let mut user = HashMap::new();
user.insert("name", "Alice");
user.insert("city", "NYC");

const user: Record<string, string> = {
    name: "Alice",
    city: "NYC",
};
const counts = new Map<string, number>();

auto name = user["name"];
auto it = user.find("city");
std::string city = (it != user.end()) ? it->second : "unknown";
bool hasEmail = user.contains("email");  // C++20
int count = counts.count("apples");      // 0 or 1

name := user["name"]
missing := user["phone"]
city, ok := user["city"]
if !ok {
    city = "unknown"
}

String name = user.get("name");
String city = user.getOrDefault("city", "unknown");
boolean hasEmail = user.containsKey("email");
int count = counts.getOrDefault("apples", 0);

name = user["name"]
city = user.get("city", "unknown")
has_email = "email" in user
phone = user.get("phone")

let name = user["name"];
let city = user.get("city").unwrap_or(&"unknown");
let has_email = user.contains_key("email");

const name = user["name"];
const city = user["city"] ?? "unknown";
const hasEmail = "email" in user;
const count = counts.get("apples") ?? 0;

auto name = user["name"];
auto it = user.find("city");
std::string city = (it != user.end()) ? it->second : "unknown";
bool hasEmail = user.contains("email");  // C++20
int count = counts.count("apples");      // 0 or 1

name := user["name"]
missing := user["phone"]
city, ok := user["city"]
if !ok {
    city = "unknown"
}

String name = user.get("name");
String city = user.getOrDefault("city", "unknown");
boolean hasEmail = user.containsKey("email");
int count = counts.getOrDefault("apples", 0);

name = user["name"]
city = user.get("city", "unknown")
has_email = "email" in user
phone = user.get("phone")

let name = user["name"];
let city = user.get("city").unwrap_or(&"unknown");
let has_email = user.contains_key("email");

const name = user["name"];
const city = user["city"] ?? "unknown";
const hasEmail = "email" in user;
const count = counts.get("apples") ?? 0;

user["email"] = "alice@example.com";
user["city"] = "LA";
user.erase("city");
counts["apples"] = 3;
counts["apples"]++;

user["email"] = "alice@example.com"
user["city"] = "LA"
delete(user, "city")
counts["apples"] = 3
counts["apples"]++

user.put("email", "alice@example.com");
user.put("city", "LA");
user.remove("city");
counts.put("apples", 3);
counts.merge("apples", 1, Integer::sum);

user["email"] = "alice@example.com"
user["city"] = "LA"
del user["city"]
merged = user | {"theme": "dark"}

user.insert("email", "alice@example.com");
user.insert("city", "LA");
user.remove("city");
*user.entry("visits").or_insert(0) += 1;

user["email"] = "alice@example.com";
user["city"] = "LA";
delete user["city"];
counts.set("apples", 3);
counts.delete("apples");

user["email"] = "alice@example.com";
user["city"] = "LA";
user.erase("city");
counts["apples"] = 3;
counts["apples"]++;

user["email"] = "alice@example.com"
user["city"] = "LA"
delete(user, "city")
counts["apples"] = 3
counts["apples"]++

user.put("email", "alice@example.com");
user.put("city", "LA");
user.remove("city");
counts.put("apples", 3);
counts.merge("apples", 1, Integer::sum);

user["email"] = "alice@example.com"
user["city"] = "LA"
del user["city"]
merged = user | {"theme": "dark"}

user.insert("email", "alice@example.com");
user.insert("city", "LA");
user.remove("city");
*user.entry("visits").or_insert(0) += 1;

user["email"] = "alice@example.com";
user["city"] = "LA";
delete user["city"];
counts.set("apples", 3);
counts.delete("apples");

for (const auto& [key, value] : user) {
    std::cout << key << ": " << value << "\n";
}
// keys and values require manual extraction
std::vector<std::string> keys;
for (const auto& [k, _] : user) {
    keys.push_back(k);
}

for key, value := range user {
    fmt.Printf("%s: %s\n", key, value)
}
keys := make([]string, 0, len(user))
for k := range user {
    keys = append(keys, k)
}

for (var entry : user.entrySet()) {
    System.out.printf("%s: %s%n", entry.getKey(), entry.getValue());
}
var keys = new ArrayList<>(user.keySet());
var values = new ArrayList<>(user.values());

for key, value in user.items():
    print(f"{key}: {value}")
keys = list(user.keys())
values = list(user.values())

for (key, value) in &user {
    println!("{key}: {value}");
}
let keys: Vec<_> = user.keys().collect();
let values: Vec<_> = user.values().collect();

for (const [key, value] of Object.entries(user)) {
    console.log(`${key}: ${value}`);
}
const keys = Object.keys(user);
const values = Object.values(user);

for (const auto& [key, value] : user) {
    std::cout << key << ": " << value << "\n";
}
// keys and values require manual extraction
std::vector<std::string> keys;
for (const auto& [k, _] : user) {
    keys.push_back(k);
}

for key, value := range user {
    fmt.Printf("%s: %s\n", key, value)
}
keys := make([]string, 0, len(user))
for k := range user {
    keys = append(keys, k)
}

for (var entry : user.entrySet()) {
    System.out.printf("%s: %s%n", entry.getKey(), entry.getValue());
}
var keys = new ArrayList<>(user.keySet());
var values = new ArrayList<>(user.values());

for key, value in user.items():
    print(f"{key}: {value}")
keys = list(user.keys())
values = list(user.values())

for (key, value) in &user {
    println!("{key}: {value}");
}
let keys: Vec<_> = user.keys().collect();
let values: Vec<_> = user.values().collect();

for (const [key, value] of Object.entries(user)) {
    console.log(`${key}: ${value}`);
}
const keys = Object.keys(user);
const values = Object.values(user);

Structs / Classes

typescript python

class Animal {
public:
    std::string name;
    std::string sound;
    Animal(std::string name, std::string sound)
        : name(std::move(name)), sound(std::move(sound)) {}
};

type Animal struct {
    Name  string
    Sound string
}

class Animal {
    final String name;
    final String sound;
    Animal(String name, String sound) {
        this.name = name;
        this.sound = sound;
    }
}

class Animal:
    def __init__(self, name: str, sound: str):
        self.name = name
        self.sound = sound

struct Animal {
    name: String,
    sound: String,
}

class Animal {
    constructor(
        public name: string,
        public sound: string,
    ) {}
}

class Animal {
public:
    std::string name;
    std::string sound;
    Animal(std::string name, std::string sound)
        : name(std::move(name)), sound(std::move(sound)) {}
};

type Animal struct {
    Name  string
    Sound string
}

class Animal {
    final String name;
    final String sound;
    Animal(String name, String sound) {
        this.name = name;
        this.sound = sound;
    }
}

class Animal:
    def __init__(self, name: str, sound: str):
        self.name = name
        self.sound = sound

struct Animal {
    name: String,
    sound: String,
}

class Animal {
    constructor(
        public name: string,
        public sound: string,
    ) {}
}

Animal dog("Rex", "woof");
Animal cat("Whiskers", "meow");
auto pet = Animal("Buddy", "bark");

dog := Animal{Name: "Rex", Sound: "woof"}
cat := Animal{"Whiskers", "meow"}
empty := Animal{}

var dog = new Animal("Rex", "woof");
var cat = new Animal("Whiskers", "meow");

dog = Animal("Rex", "woof")
cat = Animal(name="Whiskers", sound="meow")

let dog = Animal {
    name: String::from("Rex"),
    sound: String::from("woof"),
};
let cat = Animal {
    name: "Whiskers".to_string(),
    sound: "meow".to_string(),
};

const dog = new Animal("Rex", "woof");
const cat = new Animal("Whiskers", "meow");

Animal dog("Rex", "woof");
Animal cat("Whiskers", "meow");
auto pet = Animal("Buddy", "bark");

dog := Animal{Name: "Rex", Sound: "woof"}
cat := Animal{"Whiskers", "meow"}
empty := Animal{}

var dog = new Animal("Rex", "woof");
var cat = new Animal("Whiskers", "meow");

dog = Animal("Rex", "woof")
cat = Animal(name="Whiskers", sound="meow")

let dog = Animal {
    name: String::from("Rex"),
    sound: String::from("woof"),
};
let cat = Animal {
    name: "Whiskers".to_string(),
    sound: "meow".to_string(),
};

const dog = new Animal("Rex", "woof");
const cat = new Animal("Whiskers", "meow");

class Animal {
public:
    std::string name;
    std::string sound;
    Animal(std::string name, std::string sound)
        : name(std::move(name)), sound(std::move(sound)) {}
    std::string speak() const {
        return name + " says " + sound;
    }
};

func (a Animal) Speak() string {
    return fmt.Sprintf("%s says %s", a.Name, a.Sound)
}
func NewDog(name string) Animal {
    return Animal{Name: name, Sound: "woof"}
}

class Animal {
    final String name;
    final String sound;
    Animal(String name, String sound) {
        this.name = name;
        this.sound = sound;
    }
    String speak() {
        return name + " says " + sound;
    }
}

class Animal:
    def __init__(self, name: str, sound: str):
        self.name = name
        self.sound = sound
    def speak(self) -> str:
        return f"{self.name} says {self.sound}"

impl Animal {
    fn new(name: &str, sound: &str) -> Self {
        Animal { name: name.to_string(), sound: sound.to_string() }
    }
    fn speak(&self) -> String {
        format!("{} says {}", self.name, self.sound)
    }
}

class Animal {
    constructor(
        public name: string,
        public sound: string,
    ) {}
    speak(): string {
        return `${this.name} says ${this.sound}`;
    }
}

class Animal {
public:
    std::string name;
    std::string sound;
    Animal(std::string name, std::string sound)
        : name(std::move(name)), sound(std::move(sound)) {}
    std::string speak() const {
        return name + " says " + sound;
    }
};

func (a Animal) Speak() string {
    return fmt.Sprintf("%s says %s", a.Name, a.Sound)
}
func NewDog(name string) Animal {
    return Animal{Name: name, Sound: "woof"}
}

class Animal {
    final String name;
    final String sound;
    Animal(String name, String sound) {
        this.name = name;
        this.sound = sound;
    }
    String speak() {
        return name + " says " + sound;
    }
}

class Animal:
    def __init__(self, name: str, sound: str):
        self.name = name
        self.sound = sound
    def speak(self) -> str:
        return f"{self.name} says {self.sound}"

impl Animal {
    fn new(name: &str, sound: &str) -> Self {
        Animal { name: name.to_string(), sound: sound.to_string() }
    }
    fn speak(&self) -> String {
        format!("{} says {}", self.name, self.sound)
    }
}

class Animal {
    constructor(
        public name: string,
        public sound: string,
    ) {}
    speak(): string {
        return `${this.name} says ${this.sound}`;
    }
}

class Dog : public Animal {
public:
    std::vector<std::string> tricks;
    Dog(std::string name, std::vector<std::string> tricks = {})
        : Animal(std::move(name), "woof"), tricks(std::move(tricks)) {}
    std::string fetch(const std::string& item) const {
        return name + " fetches the " + item;
    }
};
Dog rex("Rex", {"sit", "shake"});
rex.speak();

type Dog struct {
    Animal
    Tricks []string
}
rex := Dog{
    Animal: Animal{Name: "Rex", Sound: "woof"},
    Tricks: []string{"sit", "shake"},
}
rex.Speak()

class Dog extends Animal {
    final List<String> tricks;
    Dog(String name, List<String> tricks) {
        super(name, "woof");
        this.tricks = tricks;
    }
    String fetch(String item) {
        return name + " fetches the " + item;
    }
}
var rex = new Dog("Rex", List.of("sit", "shake"));
rex.speak();

class Dog(Animal):
    def __init__(self, name: str, tricks: list[str] | None = None):
        super().__init__(name, "woof")
        self.tricks = tricks or []
    def fetch(self, item: str) -> str:
        return f"{self.name} fetches the {item}"
rex = Dog("Rex", ["sit", "shake"])
rex.speak()

struct Dog {
    animal: Animal,
    tricks: Vec<String>,
}
let rex = Dog {
    animal: Animal::new("Rex", "woof"),
    tricks: vec!["sit".into(), "shake".into()],
};
rex.animal.speak();

class Dog extends Animal {
    constructor(name: string, public tricks: string[] = []) {
        super(name, "woof");
    }
    fetch(item: string): string {
        return `${this.name} fetches the ${item}`;
    }
}
const rex = new Dog("Rex", ["sit", "shake"]);
rex.speak();

class Dog : public Animal {
public:
    std::vector<std::string> tricks;
    Dog(std::string name, std::vector<std::string> tricks = {})
        : Animal(std::move(name), "woof"), tricks(std::move(tricks)) {}
    std::string fetch(const std::string& item) const {
        return name + " fetches the " + item;
    }
};
Dog rex("Rex", {"sit", "shake"});
rex.speak();

type Dog struct {
    Animal
    Tricks []string
}
rex := Dog{
    Animal: Animal{Name: "Rex", Sound: "woof"},
    Tricks: []string{"sit", "shake"},
}
rex.Speak()

class Dog extends Animal {
    final List<String> tricks;
    Dog(String name, List<String> tricks) {
        super(name, "woof");
        this.tricks = tricks;
    }
    String fetch(String item) {
        return name + " fetches the " + item;
    }
}
var rex = new Dog("Rex", List.of("sit", "shake"));
rex.speak();

class Dog(Animal):
    def __init__(self, name: str, tricks: list[str] | None = None):
        super().__init__(name, "woof")
        self.tricks = tricks or []
    def fetch(self, item: str) -> str:
        return f"{self.name} fetches the {item}"
rex = Dog("Rex", ["sit", "shake"])
rex.speak()

struct Dog {
    animal: Animal,
    tricks: Vec<String>,
}
let rex = Dog {
    animal: Animal::new("Rex", "woof"),
    tricks: vec!["sit".into(), "shake".into()],
};
rex.animal.speak();

class Dog extends Animal {
    constructor(name: string, public tricks: string[] = []) {
        super(name, "woof");
    }
    fetch(item: string): string {
        return `${this.name} fetches the ${item}`;
    }
}
const rex = new Dog("Rex", ["sit", "shake"]);
rex.speak();

class Speaker {
public:
    virtual std::string speak() const = 0;
    virtual ~Speaker() = default;
};
void announce(const Speaker& s) {
    std::cout << s.speak() << "\n";
}
announce(dog);

type Speaker interface {
    Speak() string
}
func announce(s Speaker) {
    fmt.Println(s.Speak())
}
announce(dog)

interface Speaker {
    String speak();
}
void announce(Speaker s) {
    System.out.println(s.speak());
}
announce(dog);

from abc import ABC, abstractmethod
class Speaker(ABC):
    @abstractmethod
    def speak(self) -> str: ...
def announce(s: Speaker):
    print(s.speak())
announce(dog)

trait Speaker {
    fn speak(&self) -> String;
}
impl Speaker for Animal {
    fn speak(&self) -> String {
        format!("{} says {}", self.name, self.sound)
    }
}
fn announce(s: &impl Speaker) {
    println!("{}", s.speak());
}

interface Speaker {
    speak(): string;
}
function announce(s: Speaker): void {
    console.log(s.speak());
}
announce(dog);

class Speaker {
public:
    virtual std::string speak() const = 0;
    virtual ~Speaker() = default;
};
void announce(const Speaker& s) {
    std::cout << s.speak() << "\n";
}
announce(dog);

type Speaker interface {
    Speak() string
}
func announce(s Speaker) {
    fmt.Println(s.Speak())
}
announce(dog)

interface Speaker {
    String speak();
}
void announce(Speaker s) {
    System.out.println(s.speak());
}
announce(dog);

from abc import ABC, abstractmethod
class Speaker(ABC):
    @abstractmethod
    def speak(self) -> str: ...
def announce(s: Speaker):
    print(s.speak())
announce(dog)

trait Speaker {
    fn speak(&self) -> String;
}
impl Speaker for Animal {
    fn speak(&self) -> String {
        format!("{} says {}", self.name, self.sound)
    }
}
fn announce(s: &impl Speaker) {
    println!("{}", s.speak());
}

interface Speaker {
    speak(): string;
}
function announce(s: Speaker): void {
    console.log(s.speak());
}
announce(dog);

Async / Concurrency

typescript python

#include <future>
std::future<std::string> fetchData(const std::string& url) {
    return std::async(std::launch::async, [&url]() {
        return httpGet(url);
    });
}
auto data = fetchData("https://example.com").get();

ch := make(chan string, 1)
go func() {
    ch <- "hello from goroutine"
}()
msg := <-ch
fmt.Println(msg)

CompletableFuture<String> fetchData(String url) {
    return CompletableFuture.supplyAsync(() -> {
        return httpGet(url);
    });
}
String data = fetchData("https://example.com").join();

import asyncio
async def fetch_data(url: str) -> str:
    await asyncio.sleep(1)
    return f"data from {url}"
result = asyncio.run(fetch_data("https://example.com"))

async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let body = reqwest::get(url).await?.text().await?;
    Ok(body)
}
#[tokio::main]
async fn main() {
    let data = fetch_data("https://example.com").await.unwrap();
}

async function fetchData(url: string): Promise<string> {
    const res = await fetch(url);
    return res.text();
}
const data = await fetchData("https://example.com");

#include <future>
std::future<std::string> fetchData(const std::string& url) {
    return std::async(std::launch::async, [&url]() {
        return httpGet(url);
    });
}
auto data = fetchData("https://example.com").get();

ch := make(chan string, 1)
go func() {
    ch <- "hello from goroutine"
}()
msg := <-ch
fmt.Println(msg)

CompletableFuture<String> fetchData(String url) {
    return CompletableFuture.supplyAsync(() -> {
        return httpGet(url);
    });
}
String data = fetchData("https://example.com").join();

import asyncio
async def fetch_data(url: str) -> str:
    await asyncio.sleep(1)
    return f"data from {url}"
result = asyncio.run(fetch_data("https://example.com"))

async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let body = reqwest::get(url).await?.text().await?;
    Ok(body)
}
#[tokio::main]
async fn main() {
    let data = fetch_data("https://example.com").await.unwrap();
}

async function fetchData(url: string): Promise<string> {
    const res = await fetch(url);
    return res.text();
}
const data = await fetchData("https://example.com");

std::future<User> fetchUser(int id) {
    return std::async(std::launch::async, [id]() {
        return httpGetUser(id);
    });
}
auto user = fetchUser(1).get();
auto posts = fetchPosts(user.name).get();

func fetchUser(id int) <-chan User {
    ch := make(chan User, 1)
    go func() {
        user := httpGetUser(id)
        ch <- user
    }()
    return ch
}
user := <-fetchUser(1)
posts := <-fetchPosts(user.ID)

CompletableFuture<User> fetchUser(int id) {
    return CompletableFuture.supplyAsync(() -> httpGetUser(id));
}
CompletableFuture<List<Post>> fetchUserPosts(int id) {
    return fetchUser(id)
        .thenCompose(user -> fetchPosts(user.name()));
}

async def fetch_user(user_id: int) -> dict:
    data = await fetch_data(f"/api/users/{user_id}")
    return json.loads(data)
async def fetch_user_posts(user_id: int) -> list:
    user = await fetch_user(user_id)
    posts = await fetch_data(f"/api/posts?author={user['name']}")
    return json.loads(posts)

async fn fetch_user(id: u64) -> Result<User, reqwest::Error> {
    let url = format!("https://api.example.com/users/{id}");
    let user = reqwest::get(&url).await?.json::<User>().await?;
    Ok(user)
}
async fn fetch_user_posts(id: u64) -> Result<Vec<Post>, reqwest::Error> {
    let user = fetch_user(id).await?;
    let posts = fetch_posts(&user.name).await?;
    Ok(posts)
}

async function fetchUser(id: number): Promise<User> {
    const res = await fetch(`/api/users/${id}`);
    return res.json() as Promise<User>;
}
async function fetchUserPosts(id: number): Promise<Post[]> {
    const user = await fetchUser(id);
    const res = await fetch(`/api/posts?author=${user.name}`);
    return res.json() as Promise<Post[]>;
}

std::future<User> fetchUser(int id) {
    return std::async(std::launch::async, [id]() {
        return httpGetUser(id);
    });
}
auto user = fetchUser(1).get();
auto posts = fetchPosts(user.name).get();

func fetchUser(id int) <-chan User {
    ch := make(chan User, 1)
    go func() {
        user := httpGetUser(id)
        ch <- user
    }()
    return ch
}
user := <-fetchUser(1)
posts := <-fetchPosts(user.ID)

CompletableFuture<User> fetchUser(int id) {
    return CompletableFuture.supplyAsync(() -> httpGetUser(id));
}
CompletableFuture<List<Post>> fetchUserPosts(int id) {
    return fetchUser(id)
        .thenCompose(user -> fetchPosts(user.name()));
}

async def fetch_user(user_id: int) -> dict:
    data = await fetch_data(f"/api/users/{user_id}")
    return json.loads(data)
async def fetch_user_posts(user_id: int) -> list:
    user = await fetch_user(user_id)
    posts = await fetch_data(f"/api/posts?author={user['name']}")
    return json.loads(posts)

async fn fetch_user(id: u64) -> Result<User, reqwest::Error> {
    let url = format!("https://api.example.com/users/{id}");
    let user = reqwest::get(&url).await?.json::<User>().await?;
    Ok(user)
}
async fn fetch_user_posts(id: u64) -> Result<Vec<Post>, reqwest::Error> {
    let user = fetch_user(id).await?;
    let posts = fetch_posts(&user.name).await?;
    Ok(posts)
}

async function fetchUser(id: number): Promise<User> {
    const res = await fetch(`/api/users/${id}`);
    return res.json() as Promise<User>;
}
async function fetchUserPosts(id: number): Promise<Post[]> {
    const user = await fetchUser(id);
    const res = await fetch(`/api/posts?author=${user.name}`);
    return res.json() as Promise<Post[]>;
}

auto userFuture = std::async(std::launch::async, fetchUser, 1);
auto postsFuture = std::async(std::launch::async, fetchPosts);
auto user = userFuture.get();
auto posts = postsFuture.get();
std::cout << user.name << ": " << posts.size() << " posts\n";

var wg sync.WaitGroup
urls := []string{"https://a.com", "https://b.com"}
for _, url := range urls {
    wg.Add(1)
    go func(u string) {
        defer wg.Done()
        resp, _ := http.Get(u)
        fmt.Println(u, resp.StatusCode)
    }(url)
}
wg.Wait()

var userFuture = fetchUser(1);
var postsFuture = fetchPosts();
CompletableFuture.allOf(userFuture, postsFuture).join();
var user = userFuture.join();
var posts = postsFuture.join();
System.out.printf("%s: %d posts%n", user.name(), posts.size());

async def main():
    user, posts = await asyncio.gather(
        fetch_user(1),
        fetch_posts(),
    )
    print(user["name"], len(posts))
asyncio.run(main())

let user_handle = tokio::spawn(fetch_user(1));
let posts_handle = tokio::spawn(fetch_posts());
let user = user_handle.await.unwrap().unwrap();
let posts = posts_handle.await.unwrap().unwrap();
println!("{}: {} posts", user.name, posts.len());

const [user, posts]: [User, Post[]] = await Promise.all([
    fetchUser(1),
    fetchPosts(),
]);
console.log(user.name, posts.length);

auto userFuture = std::async(std::launch::async, fetchUser, 1);
auto postsFuture = std::async(std::launch::async, fetchPosts);
auto user = userFuture.get();
auto posts = postsFuture.get();
std::cout << user.name << ": " << posts.size() << " posts\n";

var wg sync.WaitGroup
urls := []string{"https://a.com", "https://b.com"}
for _, url := range urls {
    wg.Add(1)
    go func(u string) {
        defer wg.Done()
        resp, _ := http.Get(u)
        fmt.Println(u, resp.StatusCode)
    }(url)
}
wg.Wait()

var userFuture = fetchUser(1);
var postsFuture = fetchPosts();
CompletableFuture.allOf(userFuture, postsFuture).join();
var user = userFuture.join();
var posts = postsFuture.join();
System.out.printf("%s: %d posts%n", user.name(), posts.size());

async def main():
    user, posts = await asyncio.gather(
        fetch_user(1),
        fetch_posts(),
    )
    print(user["name"], len(posts))
asyncio.run(main())

let user_handle = tokio::spawn(fetch_user(1));
let posts_handle = tokio::spawn(fetch_posts());
let user = user_handle.await.unwrap().unwrap();
let posts = posts_handle.await.unwrap().unwrap();
println!("{}: {} posts", user.name, posts.len());

const [user, posts]: [User, Post[]] = await Promise.all([
    fetchUser(1),
    fetchPosts(),
]);
console.log(user.name, posts.length);

std::optional<std::string> safeFetch(const std::string& url) {
    try {
        auto future = std::async(std::launch::async, httpGet, url);
        auto status = future.wait_for(std::chrono::seconds(5));
        if (status == std::future_status::timeout) {
            std::cerr << "request timed out\n";
            return std::nullopt;
        }
        return future.get();
    } catch (const std::exception& e) {
        std::cerr << "error: " << e.what() << "\n";
        return std::nullopt;
    }
}

select {
case msg := <-ch:
    fmt.Println("received:", msg)
case err := <-errCh:
    fmt.Println("error:", err)
case <-time.After(5 * time.Second):
    fmt.Println("timeout")
}

CompletableFuture<String> safeFetch(String url) {
    return fetchData(url)
        .orTimeout(5, TimeUnit.SECONDS)
        .exceptionally(ex -> {
            System.err.println("error: " + ex.getMessage());
            return null;
        });
}

async def safe_fetch(url: str) -> str | None:
    try:
        return await fetch_data(url)
    except asyncio.TimeoutError:
        print("request timed out")
        return None
    except Exception as e:
        print(f"error: {e}")
        return None

async fn safe_fetch(url: &str) -> Option<String> {
    match tokio::time::timeout(
        Duration::from_secs(5),
        fetch_data(url),
    ).await {
        Ok(Ok(data)) => Some(data),
        Ok(Err(e)) => { eprintln!("request error: {e}"); None }
        Err(_) => { eprintln!("request timed out"); None }
    }
}

async function safeFetch(url: string): Promise<string | null> {
    try {
        const controller = new AbortController();
        setTimeout(() => controller.abort(), 5000);
        const res = await fetch(url, { signal: controller.signal });
        return res.text();
    } catch (err) {
        console.error("request failed:", err);
        return null;
    }
}

std::optional<std::string> safeFetch(const std::string& url) {
    try {
        auto future = std::async(std::launch::async, httpGet, url);
        auto status = future.wait_for(std::chrono::seconds(5));
        if (status == std::future_status::timeout) {
            std::cerr << "request timed out\n";
            return std::nullopt;
        }
        return future.get();
    } catch (const std::exception& e) {
        std::cerr << "error: " << e.what() << "\n";
        return std::nullopt;
    }
}

select {
case msg := <-ch:
    fmt.Println("received:", msg)
case err := <-errCh:
    fmt.Println("error:", err)
case <-time.After(5 * time.Second):
    fmt.Println("timeout")
}

CompletableFuture<String> safeFetch(String url) {
    return fetchData(url)
        .orTimeout(5, TimeUnit.SECONDS)
        .exceptionally(ex -> {
            System.err.println("error: " + ex.getMessage());
            return null;
        });
}

async def safe_fetch(url: str) -> str | None:
    try:
        return await fetch_data(url)
    except asyncio.TimeoutError:
        print("request timed out")
        return None
    except Exception as e:
        print(f"error: {e}")
        return None

async fn safe_fetch(url: &str) -> Option<String> {
    match tokio::time::timeout(
        Duration::from_secs(5),
        fetch_data(url),
    ).await {
        Ok(Ok(data)) => Some(data),
        Ok(Err(e)) => { eprintln!("request error: {e}"); None }
        Err(_) => { eprintln!("request timed out"); None }
    }
}

async function safeFetch(url: string): Promise<string | null> {
    try {
        const controller = new AbortController();
        setTimeout(() => controller.abort(), 5000);
        const res = await fetch(url, { signal: controller.signal });
        return res.text();
    } catch (err) {
        console.error("request failed:", err);
        return null;
    }
}

Package Management

typescript python

mkdir myapp && cd myapp
cmake -B build -S .

go mod init github.com/user/myapp

# Using Maven
mvn archetype:generate -DgroupId=com.example \
    -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart
# Using Gradle
gradle init --type java-application

python -m venv .venv
source .venv/bin/activate

cargo new myapp
cargo new mylib --lib

npm init -y
npm install -D typescript
npx tsc --init

mkdir myapp && cd myapp
cmake -B build -S .

go mod init github.com/user/myapp

# Using Maven
mvn archetype:generate -DgroupId=com.example \
    -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart
# Using Gradle
gradle init --type java-application

python -m venv .venv
source .venv/bin/activate

cargo new myapp
cargo new mylib --lib

npm init -y
npm install -D typescript
npx tsc --init

# Using vcpkg
vcpkg install fmt
vcpkg install nlohmann-json
vcpkg install boost

go get github.com/gin-gonic/gin@latest
go get golang.org/x/sync
go mod tidy

<!-- pom.xml (Maven) -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>

pip install requests
pip install -e ".[dev]"
pip freeze > requirements.txt

cargo add serde --features derive
cargo add tokio -F full
cargo add reqwest

npm install express
npm install -D @types/express
npm install -D vitest

# Using vcpkg
vcpkg install fmt
vcpkg install nlohmann-json
vcpkg install boost

go get github.com/gin-gonic/gin@latest
go get golang.org/x/sync
go mod tidy

<!-- pom.xml (Maven) -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>

pip install requests
pip install -e ".[dev]"
pip freeze > requirements.txt

cargo add serde --features derive
cargo add tokio -F full
cargo add reqwest

npm install express
npm install -D @types/express
npm install -D vitest

# CMakeLists.txt
cmake_minimum_required(VERSION 3.20)
project(myapp LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)

find_package(fmt CONFIG REQUIRED)
add_executable(myapp src/main.cpp)
target_link_libraries(myapp PRIVATE fmt::fmt)

// go.mod
module github.com/user/myapp
go 1.22
require (
    github.com/gin-gonic/gin v1.9.1
    golang.org/x/sync v0.6.0
)

<!-- pom.xml -->
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>myapp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
    </properties>
</project>

# pyproject.toml
[project]
name = "myapp"
dependencies = ["requests>=2.28"]

[project.optional-dependencies]
dev = ["pytest", "ruff"]

# Cargo.toml
[package]
name = "myapp"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "target": "ES2022",
    "module": "NodeNext",
    "outDir": "dist"
  },
  "include": ["src"]
}

# CMakeLists.txt
cmake_minimum_required(VERSION 3.20)
project(myapp LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)

find_package(fmt CONFIG REQUIRED)
add_executable(myapp src/main.cpp)
target_link_libraries(myapp PRIVATE fmt::fmt)

// go.mod
module github.com/user/myapp
go 1.22
require (
    github.com/gin-gonic/gin v1.9.1
    golang.org/x/sync v0.6.0
)

<!-- pom.xml -->
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>myapp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
    </properties>
</project>

# pyproject.toml
[project]
name = "myapp"
dependencies = ["requests>=2.28"]

[project.optional-dependencies]
dev = ["pytest", "ruff"]

# Cargo.toml
[package]
name = "myapp"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "target": "ES2022",
    "module": "NodeNext",
    "outDir": "dist"
  },
  "include": ["src"]
}

cmake --build build
cmake --build build --config Release
./build/myapp
ctest --test-dir build

go build -o myapp ./cmd/server
go run ./cmd/server
go test ./...
go install golang.org/x/tools/gopls@latest

mvn compile
mvn package
java -jar target/myapp-1.0-SNAPSHOT.jar
mvn test

pip install -r requirements.txt
python -m pytest
python -m myapp
uv pip install requests

cargo build
cargo build --release
cargo run
cargo test

npx tsc
node dist/index.js
npx tsx src/index.ts
npm test

cmake --build build
cmake --build build --config Release
./build/myapp
ctest --test-dir build

go build -o myapp ./cmd/server
go run ./cmd/server
go test ./...
go install golang.org/x/tools/gopls@latest

mvn compile
mvn package
java -jar target/myapp-1.0-SNAPSHOT.jar
mvn test

pip install -r requirements.txt
python -m pytest
python -m myapp
uv pip install requests

cargo build
cargo build --release
cargo run
cargo test

npx tsc
node dist/index.js
npx tsx src/index.ts
npm test