Code Comparison

See how 26 languages express the same programming concepts.
Click tabs to switch features.

← Back to Beauty Index Read the methodology → Score justifications →

Filter languages (0/26)

Beautiful

Handsome

Practical

Workhorses

Variable Declaration

Basic variable syntax, type annotations, and initialization patterns.

Python

name = "Python"
count: int = 0
languages: list[str] = ["Python", "Ruby"]

x, y = 10, 20
count += 1

PI: float = 3.14159

Ruby

name = "Ruby"
count = 0
languages = ["Ruby", "Python"]

x, y = 10, 20
count += 1

MAX_SIZE = 1024
@instance_var = "hello"

Elixir

name = "Elixir"
age = 12
{status, message} = {:ok, "Connected"}

[head | tail] = [1, 2, 3, 4]
%{name: lang} = %{name: "Elixir", year: 2011}

Rust

let name = "Rust";
let mut count: i32 = 0;
let (x, y) = (10, 20);

count += 1;

const MAX_SIZE: usize = 1024;
let inferred = vec![1, 2, 3];

Haskell

greeting :: String
greeting = "Hello, World!"

add :: Int -> Int -> Int
add x y = x + y

result :: Int
result = add 3 7

Clojure

(def name "Clojure")
(def languages ["Clojure" "Java"])

(let [count 0
      x 10
      y 20
      total (+ x y)]
  (println name total))

let name = "F#"
let mutable count = 0
let languages = ["F#"; "C#"; "OCaml"]

count <- count + 1

let x, y = 10, 20
let pi : float = 3.14159

Gleam

let name = "Gleam"
let count: Int = 0
let languages = ["Gleam", "Erlang"]

let #(x, y) = #(10, 20)

let result = count + x + y

Kotlin

val name = "Kotlin"
var count: Int = 0
val languages = listOf("Kotlin", "Java", "Scala")

count += 1

val (x, y) = Pair(10, 20)
val nullable: String? = null

Swift

let name = "Swift"
var count: Int = 0
let languages = ["Swift", "Objective-C"]

count += 1

let optional: String? = nil
let (x, y) = (10, 20)

Lisp

(defvar *name* "Lisp")
(defparameter *count* 0)

(let ((x 10)
      (y 20)
      (langs '("Lisp" "Scheme")))
  (+ x y (length langs)))

OCaml

let name = "OCaml"
let count = ref 0
let languages = ["OCaml"; "Haskell"]

let () = count := !count + 1

let x, y = 10, 20
let (pi : float) = 3.14159

name := "Go"
var count int = 0
languages := []string{"Go", "C"}

count++

var (
    x = 10
    y = 20
)
const MaxSize = 1024

Julia

name = "Julia"
count::Int = 0
languages = ["Julia", "Python"]

count += 1

x, y = 10, 20
const MAX_SIZE = 1024

Scala

val name = "Scala"
var count: Int = 0
val languages = List("Scala", "Java")

count += 1

val (x, y) = (10, 20)
lazy val expensive = computeResult()

Zig

const name = "Zig";
var count: i32 = 0;
const languages = [_][]const u8{ "Zig", "C" };

count += 1;

const x: u32 = 10;
const y: u32 = 20;

TypeScript

const name: string = "TypeScript";
let count = 0;
const languages: string[] = ["TS", "JS"];

count += 1;

const [x, y] = [10, 20];
const { age, ...rest } = { age: 30, name: "TS" };

char *name = "C";
int count = 0;
const char *languages[] = {"C", "C++"};

count++;

int x = 10, y = 20;
#define MAX_SIZE 1024

Lua

local name = "Lua"
local count = 0
local languages = {"Lua", "C"}

count = count + 1

local x, y = 10, 20
-- No constants in Lua

Dart

final name = 'Dart';
var count = 0;
final languages = <String>['Dart', 'Flutter'];

count++;

const maxSize = 1024;
String? nullable;
late final String deferred;

var name = "C#";
int count = 0;
var languages = new List<string> { "C#", "F#" };

count++;

var (x, y) = (10, 20);
const int MaxSize = 1024;

name <- "R"
count <- 0L
languages <- c("R", "Python")

count <- count + 1L

x <- 10; y <- 20
MAX_SIZE <- 1024L

Java

String name = "Java";
int count = 0;
var languages = List.of("Java", "Kotlin");

count++;

final int MAX_SIZE = 1024;
var x = 10;
var y = 20;

JavaScript

const name = "JavaScript";
let count = 0;
const languages = ["JS", "TS"];

count++;

const [x, y] = [10, 20];
const { age, ...rest } = { age: 30, name: "JS" };

C++

auto name = std::string("C++");
int count = 0;
auto languages = std::vector<std::string>{"C++", "C"};

count++;

auto [x, y] = std::pair(10, 20);
constexpr int MAX_SIZE = 1024;

PHP

$name = 'PHP';
$count = 0;
$languages = ['PHP', 'Python'];

$count++;

[$x, $y] = [10, 20];
define('MAX_SIZE', 1024);
const VERSION = '8.3';

If/Else

Conditional branching and control flow expressions.

Python

if score >= 90:
    label = "excellent"
elif score >= 70:
    label = "good"
elif score >= 50:
    label = "average"
else:
    label = "needs improvement"

Ruby

label = if score >= 90
          "excellent"
        elsif score >= 70
          "good"
        elsif score >= 50
          "average"
        else
          "needs improvement"
        end

Elixir

cond do
  score >= 90 -> "excellent"
  score >= 70 -> "good"
  score >= 50 -> "average"
  true        -> "needs improvement"
end

Rust

let label = if score >= 90 {
    "excellent"
} else if score >= 70 {
    "good"
} else if score >= 50 {
    "average"
} else {
    "needs improvement"
};

Haskell

classify :: Int -> String
classify n
  | n < 0     = "negative"
  | n == 0    = "zero"
  | n < 100   = "small"
  | otherwise = "large"

Clojure

(cond
  (>= score 90) "excellent"
  (>= score 70) "good"
  (>= score 50) "average"
  :else         "needs improvement")

let label =
    if score >= 90 then "excellent"
    elif score >= 70 then "good"
    elif score >= 50 then "average"
    else "needs improvement"

Gleam

let label = case score {
  s if s >= 90 -> "excellent"
  s if s >= 70 -> "good"
  s if s >= 50 -> "average"
  _ -> "needs improvement"
}

Kotlin

val label = when {
    score >= 90 -> "excellent"
    score >= 70 -> "good"
    score >= 50 -> "average"
    else -> "needs improvement"
}

Swift

var label: String
if score >= 90 {
    label = "excellent"
} else if score >= 70 {
    label = "good"
} else if score >= 50 {
    label = "average"
} else {
    label = "needs improvement"
}

Lisp

(cond
  ((>= score 90) "excellent")
  ((>= score 70) "good")
  ((>= score 50) "average")
  (t "needs improvement"))

OCaml

let label =
  if score >= 90 then "excellent"
  else if score >= 70 then "good"
  else if score >= 50 then "average"
  else "needs improvement"

var label string
if score >= 90 {
    label = "excellent"
} else if score >= 70 {
    label = "good"
} else if score >= 50 {
    label = "average"
} else {
    label = "needs improvement"
}

Julia

label = if score >= 90
    "excellent"
elseif score >= 70
    "good"
elseif score >= 50
    "average"
else
    "needs improvement"
end

Scala

val label =
  if score >= 90 then "excellent"
  else if score >= 70 then "good"
  else if score >= 50 then "average"
  else "needs improvement"

Zig

const label = if (score >= 90)
    "excellent"
else if (score >= 70)
    "good"
else if (score >= 50)
    "average"
else
    "needs improvement";

TypeScript

function describe(value: string | number): string {
  if (typeof value === "number") {
    return value > 0 ? "positive" : "non-positive";
  } else {
    return value.length > 0 ? "non-empty" : "empty";
  }
}

const char *label;
if (score >= 90) {
    label = "excellent";
} else if (score >= 70) {
    label = "good";
} else if (score >= 50) {
    label = "average";
} else {
    label = "needs improvement";
}

Lua

local label
if score >= 90 then
    label = "excellent"
elseif score >= 70 then
    label = "good"
elseif score >= 50 then
    label = "average"
else
    label = "needs improvement"
end

Dart

String classify(int? score) {
  if (score == null) return 'unknown';
  if (score >= 90) return 'excellent';
  if (score >= 70) return 'good';
  if (score >= 50) return 'average';
  return 'needs improvement';
}

var label = score switch
{
    >= 90 => "excellent",
    >= 70 => "good",
    >= 50 => "average",
    _     => "needs improvement"
};

label <- if (score >= 90) {
  "excellent"
} else if (score >= 70) {
  "good"
} else if (score >= 50) {
  "average"
} else {
  "needs improvement"
}

Java

String label;
if (score >= 90) {
    label = "excellent";
} else if (score >= 70) {
    label = "good";
} else if (score >= 50) {
    label = "average";
} else {
    label = "needs improvement";
}

JavaScript

const label = score >= 90 ? "excellent"
  : score >= 70 ? "good"
  : score >= 50 ? "average"
  : "needs improvement";

C++

std::string classify(int score) {
    if (score >= 90) return "excellent";
    else if (score >= 70) return "good";
    else if (score >= 50) return "average";
    else return "needs improvement";
}

PHP

$label = match(true) {
    $score >= 90 => 'excellent',
    $score >= 70 => 'good',
    $score >= 50 => 'average',
    default      => 'needs improvement',
};

Loops

For/while iteration patterns and loop constructs.

Python

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

for index, value in enumerate(items):
    print(f"{index}: {value}")

total = 0
while total < 100:
    total += 10

Ruby

10.times { |i| puts i }

items.each_with_index do |item, i|
  puts "#{i}: #{item}"
end

total = 0
total += 10 while total < 100

Elixir

Enum.each(1..10, fn i ->
  IO.puts(i)
end)

for x <- 1..10, rem(x, 2) == 0, do: x * x

def sum_to(0), do: 0
def sum_to(n), do: n + sum_to(n - 1)

Rust

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

let mut sum = 0;
let mut n = 1;
while n <= 100 {
    sum += n;
    n += 1;
}

Haskell

-- Haskell uses recursion, not loops
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)

evens :: [Int] -> [Int]
evens xs = [x | x <- xs, even x]

Clojure

(doseq [i (range 10)]
  (println i))

(loop [sum 0 n 1]
  (if (> n 100)
    sum
    (recur (+ sum n) (inc n))))

for i in 1 .. 10 do
    printfn "%d" i

for (index, value) in List.indexed items do
    printfn "%d: %A" index value

let mutable total = 0
while total < 100 do
    total <- total + 10

Gleam

import gleam/list
import gleam/io

pub fn print_items(items: List(String)) {
  list.each(items, fn(item) { io.println(item) })
}

pub fn sum(items: List(Int)) -> Int {
  list.fold(items, 0, fn(acc, n) { acc + n })
}

Kotlin

for (i in 1..10) {
    println(i)
}

for ((index, value) in list.withIndex()) {
    println("$index: $value")
}

var sum = 0
while (sum < 100) { sum += 10 }

Swift

for i in 1...10 {
    print(i)
}

for (index, value) in list.enumerated() {
    print("\(index): \(value)")
}

for i in stride(from: 0, to: 100, by: 5) {
    print(i)
}

Lisp

(loop for i from 1 to 10
      do (print i))

(loop for x in '(1 2 3 4 5)
      when (evenp x)
      sum x into total
      finally (return total))

OCaml

for i = 0 to 9 do
  Printf.printf "%d\n" i
done

let rec sum_to n =
  if n <= 0 then 0
  else n + sum_to (n - 1)

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

for index, value := range items {
    fmt.Printf("%d: %s\n", index, value)
}

sum := 0
for sum < 100 {
    sum += 10
}

Julia

for i in 1:10
    println(i)
end

for (i, val) in enumerate(items)
    println("$i: $val")
end

total = 0
while total < 100
    total += 10
end

Scala

for i <- 1 to 10 do
  println(i)

for
  (index, value) <- list.zipWithIndex
do println(s"$index: $value")

var sum = 0
while sum < 100 do sum += 10

Zig

for (items, 0..) |item, index| {
    std.debug.print("{}: {s}\n", .{ index, item });
}

var sum: u32 = 0;
var i: u32 = 0;
while (i < 10) : (i += 1) {
    sum += i;
}

TypeScript

for (const item of items) {
  console.log(item);
}

items.forEach((item, index) => {
  console.log(`${index}: ${item}`);
});

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

for (int i = 0; i < 10; i++) {
    printf("%d\n", i);
}

int sum = 0;
while (sum < 100) {
    sum += 10;
}

do {
    process();
} while (has_more());

Lua

for i = 1, 10 do
    print(i)
end

for index, value in ipairs(items) do
    print(index .. ": " .. value)
end

local total = 0
while total < 100 do
    total = total + 10
end

Dart

for (final item in items) {
  print(item);
}

for (var i = 0; i < 10; i++) {
  print(i);
}

var sum = 0;
while (sum < 100) { sum += 10; }

foreach (var item in items)
{
    Console.WriteLine(item);
}

for (var i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}

var sum = 0;
while (sum < 100) sum += 10;

for (i in 1:10) {
  print(i)
}

for (item in items) {
  print(item)
}

total <- 0
while (total < 100) {
  total <- total + 10
}

Java

for (var item : items) {
    System.out.println(item);
}

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

int sum = 0;
while (sum < 100) { sum += 10; }

JavaScript

for (const item of items) {
  console.log(item);
}

items.forEach((item, index) => {
  console.log(`${index}: ${item}`);
});

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

C++

for (const auto& item : items) {
    std::cout << item << "\n";
}

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

auto sum = 0;
while (sum < 100) { sum += 10; }

PHP

foreach ($items as $index => $item) {
    echo "$index: $item\n";
}

for ($i = 0; $i < 10; $i++) {
    echo "$i\n";
}

$sum = 0;
while ($sum < 100) { $sum += 10; }

Functions

Function definition, parameters, return types, and closures.

Python

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

def apply(f, x):
    return f(x)

double = lambda x: x * 2

def make_adder(n):
    return lambda x: x + n

Ruby

def greet(name)
  "Hello, #{name}!"
end

def apply(value, &block)
  block.call(value)
end

double = ->(x) { x * 2 }
triple = proc { |x| x * 3 }

Elixir

def greet(name) do
  "Hello, #{name}!"
end

def validate(input) when is_binary(input) do
  {:ok, input}
end

square = fn x -> x * x end
apply = &(&1 + &2)

Rust

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

fn apply<F, T, R>(f: F, x: T) -> R
where F: Fn(T) -> R {
    f(x)
}

let double = |x: i32| x * 2;

Haskell

greet :: String -> String
greet name = "Hello, " ++ name ++ "!"

apply :: (a -> b) -> a -> b
apply f x = f x

compose :: (b -> c) -> (a -> b) -> a -> c
compose f g x = f (g x)

Clojure

(defn greet [name]
  (str "Hello, " name "!"))

(defn apply-fn [f x]
  (f x))

(def double #(* % 2))
(def add (fn [a b] (+ a b)))

let greet name = sprintf "Hello, %s!" name

let apply f x = f x

let double = fun x -> x * 2
let add a b = a + b
let composed = greet >> String.length

Gleam

import gleam/string

pub fn greet(name: String) -> String {
  string.concat(["Hello, ", name, "!"])
}

pub fn apply(f: fn(a) -> b, x: a) -> b {
  f(x)
}

pub fn double(x: Int) -> Int {
  x * 2
}

Kotlin

fun greet(name: String): String =
    "Hello, $name!"

fun <T, R> apply(value: T, f: (T) -> R): R =
    f(value)

val double = { x: Int -> x * 2 }
val sum = listOf(1, 2, 3).fold(0) { acc, n -> acc + n }

Swift

func greet(_ name: String) -> String {
    "Hello, \(name)!"
}

func apply<T, R>(_ f: (T) -> R, to value: T) -> R {
    f(value)
}

let double = { (x: Int) in x * 2 }

Lisp

(defun greet (name)
  (format nil "Hello, ~a!" name))

(defun apply-fn (f x)
  (funcall f x))

(let ((double (lambda (x) (* x 2))))
  (apply-fn double 21))

OCaml

let greet name = Printf.sprintf "Hello, %s!" name

let apply f x = f x

let double = fun x -> x * 2
let add a b = a + b
let composed = Fun.compose String.length greet

func greet(name string) string {
    return fmt.Sprintf("Hello, %s!", name)
}

func apply(f func(int) int, x int) int {
    return f(x)
}

double := func(x int) int { return x * 2 }

Julia

function greet(name::String)::String
    "Hello, $name!"
end

greet(name) = "Hello, $name!"

double = x -> x * 2
apply(f, x) = f(x)

Scala

def greet(name: String): String =
  s"Hello, $name!"

def apply[T, R](f: T => R)(x: T): R = f(x)

val double = (x: Int) => x * 2
val add: (Int, Int) => Int = _ + _

Zig

fn greet(name: []const u8) void {
    std.debug.print("Hello, {s}!\n", .{name});
}

fn apply(comptime T: type, f: fn (T) T, x: T) T {
    return f(x);
}

TypeScript

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

const apply = <T, R>(f: (x: T) => R, x: T): R => f(x);

const double = (x: number) => x * 2;
const pipe = <T>(...fns: ((x: T) => T)[]) =>
  (x: T) => fns.reduce((v, f) => f(v), x);

char* greet(const char *name) {
    static char buf[64];
    snprintf(buf, sizeof(buf), "Hello, %s!", name);
    return buf;
}

int apply(int (*f)(int), int x) {
    return f(x);
}

Lua

function greet(name)
  return "Hello, " .. name .. "!"
end

local apply = function(f, x)
  return f(x)
end

local double = function(x) return x * 2 end

Dart

String greet(String name) => 'Hello, $name!';

T apply<T>(T Function(T) f, T x) => f(x);

final doubler = (int x) => x * 2;

void forEach<T>(List<T> items, void Function(T) action) {
  for (final item in items) action(item);
}

string Greet(string name) => $"Hello, {name}!";

T Apply<T>(Func<T, T> f, T x) => f(x);

Func<int, int> doubler = x => x * 2;
var sum = numbers.Aggregate(0, (acc, n) => acc + n);

greet <- function(name) {
  paste0("Hello, ", name, "!")
}

apply_fn <- function(f, x) f(x)

double <- function(x) x * 2

make_adder <- function(n) {
  function(x) x + n
}

Java

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

<T, R> R apply(Function<T, R> f, T x) {
    return f.apply(x);
}

Function<Integer, Integer> doubler = x -> x * 2;

JavaScript

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

const apply = (f, x) => f(x);

const double = x => x * 2;
const makeAdder = n => x => x + n;

C++

std::string greet(std::string_view name) {
    return std::format("Hello, {}!", name);
}

template<typename F, typename T>
auto apply(F f, T x) { return f(x); }

auto doubler = [](int x) { return x * 2; };

PHP

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

$apply = fn($f, $x) => $f($x);
$double = fn($x) => $x * 2;

$makeAdder = fn($n) => fn($x) => $x + $n;

Structs

Data structure definition using classes, structs, records, or equivalent.

Python

from dataclasses import dataclass

@dataclass
class User:
    name: str
    email: str
    age: int = 0

    def greeting(self) -> str:
        return f"Hello, {self.name}!"

Ruby

User = Struct.new(:name, :email, :age) do
  def greeting
    "Hello, #{name}!"
  end
end

user = User.new("Alice", "alice@ex.com", 30)
puts user.greeting

Elixir

defmodule User do
  defstruct [:name, :email, age: 0]

  def new(name, email, age) do
    %User{name: name, email: email, age: age}
  end

  def greeting(%User{name: name}) do
    "Hello, #{name}!"
  end
end

Rust

#[derive(Debug, Clone)]
struct User {
    name: String,
    email: String,
    age: u32,
}

impl User {
    fn new(name: &str, email: &str, age: u32) -> Self {
        Self { name: name.into(), email: email.into(), age }
    }
}

Haskell

data User = User
  { userName  :: String
  , userEmail :: String
  , userAge   :: Int
  } deriving (Show, Eq)

data Shape
  = Circle Double
  | Rectangle Double Double

Clojure

(defrecord User [name email age])

(defprotocol Greetable
  (greeting [this]))

(extend-type User
  Greetable
  (greeting [this]
    (str "Hello, " (:name this) "!")))

(def user (->User "Alice" "alice@ex.com" 30))

type User =
    { Name: string
      Email: string
      Age: int }
    member this.Greeting = sprintf "Hello, %s!" this.Name

let user = { Name = "Alice"; Email = "a@b.c"; Age = 30 }
let updated = { user with Age = 31 }

Gleam

import gleam/string

pub type User {
  User(name: String, email: String, age: Int)
}

pub fn greeting(user: User) -> String {
  string.concat(["Hello, ", user.name, "!"])
}

pub fn new_user(name: String, email: String) -> User {
  User(name: name, email: email, age: 0)
}

Kotlin

data class User(
    val name: String,
    val email: String,
    val age: Int
) {
    fun greeting(): String = "Hello, $name!"
}

val user = User("Alice", "alice@ex.com", 30)
val updated = user.copy(age = 31)

Swift

struct User: Codable, Equatable {
    let name: String
    let email: String
    var age: Int

    func greeting() -> String {
        "Hello, \(name)!"
    }
}

let user = User(name: "Alice", email: "a@b.c", age: 30)

Lisp

(defclass user ()
  ((name :initarg :name :accessor user-name)
   (age  :initarg :age  :accessor user-age)))

(defgeneric greet (obj))
(defmethod greet ((u user))
  (format nil "Hello, ~a!" (user-name u)))

(greet (make-instance 'user
         :name "Alice" :age 30))

OCaml

type user = {
  name : string;
  email : string;
  age : int;
}

let greeting u = Printf.sprintf "Hello, %s!" u.name

let user = { name = "Alice"; email = "a@b.c"; age = 30 }
let updated = { user with age = 31 }

type User struct {
    Name  string
    Email string
    Age   int
}

func NewUser(name, email string, age int) User {
    return User{Name: name, Email: email, Age: age}
}

func (u User) Greeting() string {
    return fmt.Sprintf("Hello, %s!", u.Name)
}

Julia

struct User
    name::String
    email::String
    age::Int
end

greeting(u::User) = "Hello, $(u.name)!"

mutable struct MutableUser
    name::String
    age::Int
end

Scala

case class User(
    name: String,
    email: String,
    age: Int = 0
):
  def greeting: String = s"Hello, $name!"

val user = User("Alice", "alice@ex.com", 30)
val updated = user.copy(age = 31)

Zig

const User = struct {
    name: []const u8,
    email: []const u8,
    age: u32,

    pub fn greeting(self: User) void {
        std.debug.print("Hello, {s}!\n", .{self.name});
    }
};

const user = User{ .name = "Alice", .email = "a@b.c", .age = 30 };

TypeScript

interface User {
  readonly name: string;
  readonly email: string;
  age: number;
}

class UserImpl implements User {
  constructor(
    public readonly name: string,
    public readonly email: string,
    public age: number
  ) {}

  greeting(): string { return `Hello, ${this.name}!`; }
}

typedef struct {
    char name[64];
    char email[128];
    int age;
} User;

void user_greeting(const User *u) {
    printf("Hello, %s!\n", u->name);
}

User user = { .name = "Alice", .email = "a@b.c", .age = 30 };

Lua

local User = {}
User.__index = User

function User.new(name, email, age)
  return setmetatable({
    name = name, email = email, age = age
  }, User)
end

function User:greeting()
  return "Hello, " .. self.name .. "!"
end

Dart

class User {
  final String name;
  final String email;
  final int age;

  const User({
    required this.name,
    required this.email,
    this.age = 0,
  });

  String greeting() => 'Hello, $name!';
}

public record User(
    string Name,
    string Email,
    int Age = 0
) {
    public string Greeting() => $"Hello, {Name}!";
}

var user = new User("Alice", "alice@ex.com", 30);
var updated = user with { Age = 31 };

new_user <- function(name, email, age = 0L) {
  structure(
    list(name = name, email = email, age = age),
    class = "User"
  )
}

greeting <- function(user, ...) UseMethod("greeting")

greeting.User <- function(user, ...) {
  paste0("Hello, ", user$name, "!")
}

Java

public record User(
    String name,
    String email,
    int age
) {
    public String greeting() {
        return "Hello, " + name + "!";
    }
}

var user = new User("Alice", "alice@ex.com", 30);

JavaScript

class User {
  constructor(name, email, age = 0) {
    this.name = name;
    this.email = email;
    this.age = age;
  }

  greeting() {
    return `Hello, ${this.name}!`;
  }
}

C++

struct User {
    std::string name;
    std::string email;
    int age;

    User(std::string n, std::string e, int a)
        : name(std::move(n)), email(std::move(e)), age(a) {}

    std::string greeting() const {
        return std::format("Hello, {}!", name);
    }
};

PHP

readonly class User {
    public function __construct(
        public string $name,
        public string $email,
        public int $age = 0,
    ) {}

    public function greeting(): string {
        return "Hello, {$this->name}!";
    }
}

Pattern Matching

Native pattern matching constructs for destructuring and control flow.

Python

match command:
    case ["quit"]:
        quit()
    case ["go", direction]:
        move(direction)
    case ["get", item] if item in inventory:
        pick_up(item)
    case _:
        print("Unknown command")

Ruby

case data
in { name: String => name, age: (18..) => age }
  puts "Adult: #{name}, #{age}"
in { name: String => name, age: Integer => age }
  puts "Minor: #{name}, #{age}"
in [Integer => x, Integer => y]
  puts "Point: #{x}, #{y}"
end

Elixir

case list do
  [] -> "empty"
  [x] -> "just #{x}"
  [h | _] when h > 0 -> "starts positive"
  _ -> "other"
end

# Function clause pattern matching (inside a module)
# def handle({:ok, result}), do: result
# def handle({:error, reason}), do: raise reason

{:ok, value} = {:ok, 42}

Rust

fn describe(value: &Option<Vec<i32>>) -> &str {
    match value {
        None => "nothing",
        Some(v) if v.is_empty() => "empty list",
        Some(v) if v.len() == 1 => "singleton",
        Some(v) => "list",
    }
}

Haskell

describe :: (Show a, Num a, Ord a) => [a] -> String
describe xs = case xs of
  []    -> "empty"
  [x]   -> "singleton: " ++ show x
  [x,y] -> "pair: " ++ show x ++ "," ++ show y
  (x:_) | x > 0     -> "starts positive"
         | otherwise -> "starts non-positive"

Clojure

(require '[clojure.core.match :refer [match]])

(match [x y]
  [_ 0] "y is zero"
  [0 _] "x is zero"
  [a b] (str "both non-zero: " a ", " b))

(let [{:keys [name age]} person]
  (str name " is " age))

let describe = function
    | [] -> "empty"
    | [x] -> sprintf "singleton: %A" x
    | x :: _ when x > 0 -> "starts positive"
    | _ -> "other"

let area = function
    | Circle r -> System.Math.PI * r * r
    | Rect (w, h) -> w * h

Gleam

pub fn describe(items: List(Int)) -> String {
  case items {
    [] -> "empty"
    [x] -> "singleton"
    [x, ..] if x > 0 -> "starts positive"
    _ -> "other"
  }
}

pub fn unwrap(result: Result(a, b), default: a) -> a {
  case result {
    Ok(value) -> value
    Error(_) -> default
  }
}

Kotlin

fun describe(shape: Shape): String = when (shape) {
    is Circle -> "circle r=${shape.radius}"
    is Rectangle -> "rect ${shape.w}x${shape.h}"
    is Triangle -> "triangle"
}

val (name, age) = person
when {
    age < 18 -> "minor"
    else -> "adult"
}

Swift

func describe(_ value: Any) -> String {
    switch value {
    case let n as Int where n > 0:
        return "positive int: \(n)"
    case let s as String:
        return "string: \(s)"
    case let (x, y) as (Int, Int):
        return "pair: \(x), \(y)"
    default:
        return "unknown"
    }
}

Lisp

(defun describe-val (x)
  (typecase x
    (integer (format nil "int: ~d" x))
    (string  (format nil "str: ~a" x))
    (list    (format nil "~d items" (length x)))
    (t       "unknown")))

(describe-val 42)
(describe-val '(1 2 3))

OCaml

let describe = function
  | [] -> "empty"
  | [x] -> Printf.sprintf "singleton: %d" x
  | x :: _ when x > 0 -> "starts positive"
  | _ -> "other"

let area = function
  | Circle r -> Float.pi *. r *. r
  | Rect (w, h) -> w *. h