Static members, class methods and factories

Python 3.14 · main.py

class Ticket:
    issued = 0  # one count, shared by every ticket

    def __init__(self, show: str) -> None:
        Ticket.issued += 1
        self.number = Ticket.issued  # each ticket's own number
        self.show = show

    @staticmethod
    def label(number: int) -> str:
        return f"T-{number:03d}"


tickets = [Ticket("matinee"), Ticket("matinee"), Ticket("evening")]
for ticket in tickets:
    print(f"{Ticket.label(ticket.number)} for the {ticket.show} show")
print(f"issued so far: {Ticket.issued}")

In Python: issued is a class attribute, read and changed as Ticket.issued. self.issued += 1 would instead give one ticket an attribute of its own and leave the class's count at 0.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

class Ticket {
  static #issued = 0; // one count, shared by every ticket

  constructor(show) {
    Ticket.#issued += 1;
    this.number = Ticket.#issued; // each ticket's own number
    this.show = show;
  }

  static get issued() {
    return Ticket.#issued;
  }

  static label(number) {
    return `T-${String(number).padStart(3, "0")}`;
  }
}

const tickets = [new Ticket("matinee"), new Ticket("matinee"), new Ticket("evening")];
for (const ticket of tickets) {
  console.log(`${Ticket.label(ticket.number)} for the ${ticket.show} show`);
}
console.log(`issued so far: ${Ticket.issued}`);

In JavaScript: static #issued belongs to the class and is private; the static getter issued and the static method label are called on Ticket itself, never on a ticket.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.util.List;
import java.util.Locale;

public class Main {
  public static void main(String[] args) {
    Locale.setDefault(Locale.ROOT);
    List<Ticket> tickets =
        List.of(new Ticket("matinee"), new Ticket("matinee"), new Ticket("evening"));
    for (Ticket ticket : tickets) {
      System.out.println(Ticket.label(ticket.number()) + " for the " + ticket.show() + " show");
    }
    System.out.println("issued so far: " + Ticket.issuedSoFar());
  }
}

final class Ticket {
  private static int issued = 0; // one count, shared by every ticket
  private final int number;
  private final String show;

  Ticket(String show) {
    issued += 1;
    this.number = issued; // each ticket's own number
    this.show = show;
  }

  int number() {
    return number;
  }

  String show() {
    return show;
  }

  static int issuedSoFar() {
    return issued;
  }

  static String label(int number) {
    return String.format("T-%03d", number);
  }
}

In Java: static int issued has one copy for the class. A static method such as label has no this, so it can use only its parameters and other static members.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <format>
#include <print>
#include <string>
#include <utility>
#include <vector>

class Ticket {
public:
  explicit Ticket(std::string show) : show_(std::move(show)) {
    issued_ += 1;
    number_ = issued_; // each ticket's own number
  }

  int number() const { return number_; }
  const std::string &show() const { return show_; }

  static int issued() { return issued_; }
  static std::string label(int number) {
    return std::format("T-{:03}", number);
  }

private:
  inline static int issued_ = 0; // one count, shared by every ticket
  int number_ = 0;
  std::string show_;
};

int main() {
  std::vector<Ticket> tickets;
  tickets.emplace_back("matinee");
  tickets.emplace_back("matinee");
  tickets.emplace_back("evening");
  for (const Ticket &ticket : tickets) {
    std::println("{} for the {} show", Ticket::label(ticket.number()),
                 ticket.show());
  }
  std::println("issued so far: {}", Ticket::issued());
}

In C++: inline static, new in C++17, defines the shared count inside the class. A static member function has no this pointer, so label could not read number_.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

Ticket[] tickets = [new("matinee"), new("matinee"), new("evening")];
foreach (var ticket in tickets)
{
    Console.WriteLine($"{Ticket.Label(ticket.Number)} for the {ticket.Show} show");
}
Console.WriteLine($"issued so far: {Ticket.Issued}");

sealed class Ticket
{
    public static int Issued { get; private set; } // one count, shared by every ticket

    public int Number { get; }
    public string Show { get; }

    public Ticket(string show)
    {
        Issued += 1;
        Number = Issued; // each ticket's own number
        Show = show;
    }

    public static string Label(int number) => $"T-{number:D3}";
}

In C#: A static auto-property with private set belongs to the type itself. Code reads Ticket.Issued, and only the class can change it.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stddef.h>
#include <stdio.h>

static int tickets_issued = 0; // one count, shared by every ticket

struct ticket {
  int number;
  const char *show;
};

static struct ticket ticket_new(const char *show) {
  tickets_issued += 1;
  return (struct ticket){.number = tickets_issued, // each ticket's own number
                         .show = show};
}

static void ticket_label(int number, char *out, size_t size) {
  snprintf(out, size, "T-%03d", number);
}

int main(void) {
  const struct ticket first = ticket_new("matinee");
  const struct ticket second = ticket_new("matinee");
  const struct ticket third = ticket_new("evening");
  const struct ticket tickets[] = {first, second, third};
  char label[16];
  for (size_t i = 0; i < sizeof tickets / sizeof tickets[0]; i++) {
    ticket_label(tickets[i].number, label, sizeof label);
    printf("%s for the %s show\n", label, tickets[i].show);
  }
  printf("issued so far: %d\n", tickets_issued);
  return 0;
}

In C: C has no classes, so the shared count is a variable at file scope, where static means private to this file. C leaves the order of the calls in one initializer list unspecified, so each ticket is made in a statement of its own.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

final class Ticket
{
    private static int $issued = 0; // one count, shared by every ticket

    public readonly int $number;

    public function __construct(public readonly string $show)
    {
        self::$issued += 1;
        $this->number = self::$issued; // each ticket's own number
    }

    public static function issuedSoFar(): int
    {
        return self::$issued;
    }

    public static function label(int $number): string
    {
        return sprintf('T-%03d', $number);
    }
}

$tickets = [new Ticket('matinee'), new Ticket('matinee'), new Ticket('evening')];
foreach ($tickets as $ticket) {
    echo Ticket::label($ticket->number) . " for the {$ticket->show} show\n";
}
echo 'issued so far: ' . Ticket::issuedSoFar() . "\n";

In PHP: self::$issued names the class's own static property, and readonly properties, from PHP 8.1, may be written only once, in the constructor.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

use std::sync::atomic::{AtomicU32, Ordering};

static ISSUED: AtomicU32 = AtomicU32::new(0); // one count, shared by every ticket

struct Ticket {
    number: u32,
    show: String,
}

impl Ticket {
    fn new(show: &str) -> Self {
        let number = ISSUED.fetch_add(1, Ordering::Relaxed) + 1; // each ticket's own number
        Ticket {
            number,
            show: show.to_string(),
        }
    }

    fn issued() -> u32 {
        ISSUED.load(Ordering::Relaxed)
    }

    fn label(number: u32) -> String {
        format!("T-{number:03}")
    }
}

fn main() {
    let tickets = [
        Ticket::new("matinee"),
        Ticket::new("matinee"),
        Ticket::new("evening"),
    ];
    for ticket in &tickets {
        println!(
            "{} for the {} show",
            Ticket::label(ticket.number),
            ticket.show
        );
    }
    println!("issued so far: {}", Ticket::issued());
}

In Rust: A Rust type has no static fields, and a static mut needs unsafe code, so the count is an atomic static. Ticket::label is an associated function, Rust's static method.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

class Ticket {
  static #issued = 0; // one count, shared by every ticket
  readonly number: number;
  readonly show: string;

  constructor(show: string) {
    Ticket.#issued += 1;
    this.number = Ticket.#issued; // each ticket's own number
    this.show = show;
  }

  static get issued(): number {
    return Ticket.#issued;
  }

  static label(number: number): string {
    return `T-${String(number).padStart(3, "0")}`;
  }
}

const tickets = [new Ticket("matinee"), new Ticket("matinee"), new Ticket("evening")];
for (const ticket of tickets) {
  console.log(`${Ticket.label(ticket.number)} for the ${ticket.show} show`);
}
console.log(`issued so far: ${Ticket.issued}`);

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import "fmt"

var issued int // one count, shared by every ticket

type Ticket struct {
	number int
	show   string
}

func NewTicket(show string) *Ticket {
	issued++
	return &Ticket{number: issued, show: show} // each ticket's own number
}

func Label(number int) string {
	return fmt.Sprintf("T-%03d", number)
}

func main() {
	tickets := []*Ticket{NewTicket("matinee"), NewTicket("matinee"), NewTicket("evening")}
	for _, ticket := range tickets {
		fmt.Printf("%s for the %s show\n", Label(ticket.number), ticket.show)
	}
	fmt.Printf("issued so far: %d\n", issued)
}

In Go: Go has no static members. A package-level variable holds the shared count, and Label is a plain function of the package.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

final class Ticket {
  private(set) static var issued = 0  // one count, shared by every ticket

  let number: Int
  let show: String

  init(show: String) {
    Ticket.issued += 1
    number = Ticket.issued  // each ticket's own number
    self.show = show
  }

  static func label(_ number: Int) -> String {
    let digits = String(number)
    return "T-" + String(repeating: "0", count: max(0, 3 - digits.count)) + digits
  }
}

let tickets = [Ticket(show: "matinee"), Ticket(show: "matinee"), Ticket(show: "evening")]
for ticket in tickets {
  print("\(Ticket.label(ticket.number)) for the \(ticket.show) show")
}
print("issued so far: \(Ticket.issued)")

In Swift: static var issued belongs to the class, and private(set) lets only Ticket change it. Static methods are called on the type, as in Ticket.label(2).

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

# A ticket for one show, numbered from a count kept by the class.
class Ticket
  @issued = 0 # one count, shared by every ticket

  class << self
    attr_reader :issued

    def label(number)
      "T-#{number.to_s.rjust(3, '0')}"
    end

    def next_number
      @issued += 1
    end
  end

  attr_reader :number, :show

  def initialize(show)
    @number = Ticket.next_number # each ticket's own number
    @show = show
  end
end

tickets = [Ticket.new('matinee'), Ticket.new('matinee'), Ticket.new('evening')]
tickets.each do |ticket|
  puts "#{Ticket.label(ticket.number)} for the #{ticket.show} show"
end
puts "issued so far: #{Ticket.issued}"

In Ruby: @issued in the class body is an instance variable of the class object itself, which class << self exposes. A @@ class variable would also be shared with subclasses.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

class Ticket(
    val show: String,
) {
    val number: Int

    init {
        issued += 1
        number = issued // each ticket's own number
    }

    companion object {
        var issued = 0 // one count, shared by every ticket
            private set

        fun label(number: Int): String = "T-${number.toString().padStart(3, '0')}"
    }
}

fun main() {
    val tickets = listOf(Ticket("matinee"), Ticket("matinee"), Ticket("evening"))
    for (ticket in tickets) {
        println("${Ticket.label(ticket.number)} for the ${ticket.show} show")
    }
    println("issued so far: ${Ticket.issued}")
}

In Kotlin: Kotlin has no static keyword. Members of the companion object belong to the class, and the init block runs once for each new ticket.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

class Ticket {
  Ticket(this.show) : number = ++_issued; // each ticket's own number

  static int _issued = 0; // one count, shared by every ticket

  final int number;
  final String show;

  static int get issued => _issued;

  static String label(int number) => 'T-${number.toString().padLeft(3, '0')}';
}

void main() {
  final tickets = [Ticket('matinee'), Ticket('matinee'), Ticket('evening')];
  for (final ticket in tickets) {
    print('${Ticket.label(ticket.number)} for the ${ticket.show} show');
  }
  print('issued so far: ${Ticket.issued}');
}

In Dart: Static members belong to the class. The initializer list, number = ++_issued, sets the final field before the constructor's body runs.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart

Python 3.14 · main.py

class Distance:
    def __init__(self, metres: int) -> None:
        if metres < 0:
            raise ValueError(f"a distance cannot be negative: {metres} m")
        self.metres = metres

    # Named factories: each name says which unit its number is in.
    @classmethod
    def from_metres(cls, metres: int) -> "Distance":
        return cls(metres)

    @classmethod
    def from_kilometres(cls, kilometres: int) -> "Distance":
        return cls(kilometres * 1000)


run = Distance.from_kilometres(5)
lap = Distance.from_metres(400)
print(f"run: {run.metres} m, lap: {lap.metres} m")
print(
    f"laps in the run: {run.metres // lap.metres}, then {run.metres % lap.metres} m more"
)
try:
    Distance.from_kilometres(-2)
except ValueError as error:
    print(f"refused: {error}")

In Python: @classmethod passes the class as cls, so cls(kilometres * 1000) builds whatever class the factory was called on. Python cannot make __init__ private, so Distance(5000) still works.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

class Distance {
  constructor(metres) {
    if (metres < 0) {
      throw new RangeError(`a distance cannot be negative: ${metres} m`);
    }
    this.metres = metres;
  }

  // Named factories: each name says which unit its number is in.
  static fromMetres(metres) {
    return new Distance(metres);
  }

  static fromKilometres(kilometres) {
    return new Distance(kilometres * 1000);
  }
}

const run = Distance.fromKilometres(5);
const lap = Distance.fromMetres(400);
console.log(`run: ${run.metres} m, lap: ${lap.metres} m`);
const laps = Math.trunc(run.metres / lap.metres);
console.log(`laps in the run: ${laps}, then ${run.metres % lap.metres} m more`);
try {
  Distance.fromKilometres(-2);
} catch (error) {
  console.log(`refused: ${error.message}`);
}

In JavaScript: A JavaScript constructor cannot be private, so new Distance(5000) still works beside the factories. Math.trunc stands in for integer division.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

public class Main {
  public static void main(String[] args) {
    Distance run = Distance.fromKilometres(5);
    Distance lap = Distance.fromMetres(400);
    System.out.println("run: " + run.metres() + " m, lap: " + lap.metres() + " m");
    int laps = run.metres() / lap.metres();
    System.out.println(
        "laps in the run: " + laps + ", then " + run.metres() % lap.metres() + " m more");
    try {
      Distance.fromKilometres(-2);
    } catch (IllegalArgumentException error) {
      System.out.println("refused: " + error.getMessage());
    }
  }
}

record Distance(int metres) {
  Distance {
    if (metres < 0) {
      throw new IllegalArgumentException("a distance cannot be negative: " + metres + " m");
    }
  }

  // Named factories: each name says which unit its number is in.
  static Distance fromMetres(int metres) {
    return new Distance(metres);
  }

  static Distance fromKilometres(int kilometres) {
    return new Distance(kilometres * 1000);
  }
}

In Java: Distance is a record whose compact constructor checks the value. A record with package access may not make that constructor private, so new Distance(5000) still compiles. The java.time classes name such factories of…, as in Duration.ofMinutes(90).

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <format>
#include <print>
#include <stdexcept>

class Distance {
public:
  // Named factories: each name says which unit its number is in.
  static Distance from_metres(int metres) { return Distance(metres); }
  static Distance from_kilometres(int kilometres) {
    return Distance(kilometres * 1000);
  }

  int metres() const { return metres_; }

private:
  explicit Distance(int metres) : metres_(metres) {
    if (metres < 0) {
      throw std::invalid_argument(
          std::format("a distance cannot be negative: {} m", metres));
    }
  }

  int metres_;
};

int main() {
  const Distance run = Distance::from_kilometres(5);
  const Distance lap = Distance::from_metres(400);
  std::println("run: {} m, lap: {} m", run.metres(), lap.metres());
  std::println("laps in the run: {}, then {} m more",
               run.metres() / lap.metres(), run.metres() % lap.metres());
  try {
    Distance::from_kilometres(-2);
  } catch (const std::invalid_argument &error) {
    std::println("refused: {}", error.what());
  }
}

In C++: The constructor is private, so the two factories are the only way to make a Distance, and explicit stops an int from turning into one by accident.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

var run = Distance.FromKilometres(5);
var lap = Distance.FromMetres(400);
Console.WriteLine($"run: {run.Metres} m, lap: {lap.Metres} m");
int laps = run.Metres / lap.Metres;
Console.WriteLine($"laps in the run: {laps}, then {run.Metres % lap.Metres} m more");
try
{
    Distance.FromKilometres(-2);
}
catch (ArgumentException error)
{
    Console.WriteLine($"refused: {error.Message}");
}

sealed class Distance
{
    public int Metres { get; }

    private Distance(int metres)
    {
        if (metres < 0)
        {
            throw new ArgumentException($"a distance cannot be negative: {metres} m");
        }
        Metres = metres;
    }

    // Named factories: each name says which unit its number is in.
    public static Distance FromMetres(int metres) => new(metres);

    public static Distance FromKilometres(int kilometres) => new(kilometres * 1000);
}

In C#: The private constructor leaves FromMetres and FromKilometres as the only way in. The TimeSpan.FromMinutes(90) of .NET is the same pattern.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stddef.h>
#include <stdio.h>

struct distance {
  int metres;
};

// Named factories: each name says which unit its number is in.
static bool distance_from_metres(int metres, struct distance *out, char *why,
                                 size_t size) {
  if (metres < 0) {
    snprintf(why, size, "a distance cannot be negative: %d m", metres);
    return false;
  }
  out->metres = metres;
  return true;
}

static bool distance_from_kilometres(int kilometres, struct distance *out,
                                     char *why, size_t size) {
  return distance_from_metres(kilometres * 1000, out, why, size);
}

int main(void) {
  char why[64];
  struct distance run;
  struct distance lap;
  distance_from_kilometres(5, &run, why, sizeof why);
  distance_from_metres(400, &lap, why, sizeof why);
  printf("run: %d m, lap: %d m\n", run.metres, lap.metres);
  printf("laps in the run: %d, then %d m more\n", run.metres / lap.metres,
         run.metres % lap.metres);
  struct distance refused;
  if (!distance_from_kilometres(-2, &refused, why, sizeof why)) {
    printf("refused: %s\n", why);
  }
  return 0;
}

In C: C has no static methods. The factories are functions that fill in a struct and report a refusal through their return value and a message buffer.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

final class Distance
{
    private function __construct(public readonly int $metres)
    {
        if ($metres < 0) {
            throw new InvalidArgumentException("a distance cannot be negative: {$metres} m");
        }
    }

    // Named factories: each name says which unit its number is in.
    public static function fromMetres(int $metres): self
    {
        return new self($metres);
    }

    public static function fromKilometres(int $kilometres): self
    {
        return new self($kilometres * 1000);
    }
}

$run = Distance::fromKilometres(5);
$lap = Distance::fromMetres(400);
echo "run: {$run->metres} m, lap: {$lap->metres} m\n";
$laps = intdiv($run->metres, $lap->metres);
echo "laps in the run: {$laps}, then " . $run->metres % $lap->metres . " m more\n";
try {
    Distance::fromKilometres(-2);
} catch (InvalidArgumentException $error) {
    echo "refused: {$error->getMessage()}\n";
}

In PHP: The constructor is private, and self, in the return types and in new self(…), names the class itself.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

struct Distance {
    metres: i32,
}

impl Distance {
    fn new(metres: i32) -> Result<Self, String> {
        if metres < 0 {
            return Err(format!("a distance cannot be negative: {metres} m"));
        }
        Ok(Distance { metres })
    }

    // Named factories: each name says which unit its number is in.
    fn from_metres(metres: i32) -> Result<Self, String> {
        Distance::new(metres)
    }

    fn from_kilometres(kilometres: i32) -> Result<Self, String> {
        Distance::new(kilometres * 1000)
    }
}

fn main() -> Result<(), String> {
    let run = Distance::from_kilometres(5)?;
    let lap = Distance::from_metres(400)?;
    println!("run: {} m, lap: {} m", run.metres, lap.metres);
    println!(
        "laps in the run: {}, then {} m more",
        run.metres / lap.metres,
        run.metres % lap.metres
    );
    if let Err(why) = Distance::from_kilometres(-2) {
        println!("refused: {why}");
    }
    Ok(())
}

In Rust: Rust has no constructors. new and the from_ functions are associated functions, Rust's static methods, and each returns a Result.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

class Distance {
  readonly metres: number;

  constructor(metres: number) {
    if (metres < 0) {
      throw new RangeError(`a distance cannot be negative: ${metres} m`);
    }
    this.metres = metres;
  }

  // Named factories: each name says which unit its number is in.
  static fromMetres(metres: number): Distance {
    return new Distance(metres);
  }

  static fromKilometres(kilometres: number): Distance {
    return new Distance(kilometres * 1000);
  }
}

const run = Distance.fromKilometres(5);
const lap = Distance.fromMetres(400);
console.log(`run: ${run.metres} m, lap: ${lap.metres} m`);
const laps = Math.trunc(run.metres / lap.metres);
console.log(`laps in the run: ${laps}, then ${run.metres % lap.metres} m more`);
try {
  Distance.fromKilometres(-2);
} catch (error) {
  console.log(`refused: ${error instanceof Error ? error.message : String(error)}`);
}

In TypeScript: TypeScript could mark the constructor private, a check the compiler alone makes; this version keeps it public, as the JavaScript one must.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import "fmt"

type Distance struct {
	metres int
}

func newDistance(metres int) (Distance, error) {
	if metres < 0 {
		return Distance{}, fmt.Errorf("a distance cannot be negative: %d m", metres)
	}
	return Distance{metres: metres}, nil
}

// Named factories: each name says which unit its number is in.
func FromMetres(metres int) (Distance, error) {
	return newDistance(metres)
}

func FromKilometres(kilometres int) (Distance, error) {
	return newDistance(kilometres * 1000)
}

func main() {
	run, err := FromKilometres(5)
	if err != nil {
		fmt.Println(err)
		return
	}
	lap, err := FromMetres(400)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("run: %d m, lap: %d m\n", run.metres, lap.metres)
	laps := run.metres / lap.metres
	fmt.Printf("laps in the run: %d, then %d m more\n", laps, run.metres%lap.metres)
	if _, err := FromKilometres(-2); err != nil {
		fmt.Printf("refused: %v\n", err)
	}
}

In Go: Go has no static methods. FromMetres and FromKilometres are package functions, and lowercase newDistance cannot be called from another package.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

struct Refused: Error, CustomStringConvertible {
  let description: String
}

struct Distance {
  let metres: Int

  private init(metres: Int) throws(Refused) {
    guard metres >= 0 else {
      throw Refused(description: "a distance cannot be negative: \(metres) m")
    }
    self.metres = metres
  }

  // Named factories: each name says which unit its number is in.
  static func fromMetres(_ metres: Int) throws(Refused) -> Distance {
    try Distance(metres: metres)
  }

  static func fromKilometres(_ kilometres: Int) throws(Refused) -> Distance {
    try Distance(metres: kilometres * 1000)
  }
}

let run = try Distance.fromKilometres(5)
let lap = try Distance.fromMetres(400)
print("run: \(run.metres) m, lap: \(lap.metres) m")
print("laps in the run: \(run.metres / lap.metres), then \(run.metres % lap.metres) m more")
do {
  _ = try Distance.fromKilometres(-2)
} catch {
  print("refused: \(error)")
}

In Swift: The initializer is private, so from outside the type the static functions are the only way in, and typed throws report the refused value.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

# A distance kept in whole metres.
class Distance
  attr_reader :metres

  def initialize(metres)
    raise ArgumentError, "a distance cannot be negative: #{metres} m" if metres.negative?

    @metres = metres
  end

  # Named factories: each name says which unit its number is in.
  def self.from_metres(metres)
    new(metres)
  end

  def self.from_kilometres(kilometres)
    new(kilometres * 1000)
  end
end

run = Distance.from_kilometres(5)
lap = Distance.from_metres(400)
puts "run: #{run.metres} m, lap: #{lap.metres} m"
puts "laps in the run: #{run.metres / lap.metres}, then #{run.metres % lap.metres} m more"
begin
  Distance.from_kilometres(-2)
rescue ArgumentError => e
  puts "refused: #{e.message}"
end

In Ruby: def self.from_metres defines a method on the class itself. new stays public unless private_class_method :new hides it.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

class Distance private constructor(
    val metres: Int,
) {
    init {
        require(metres >= 0) { "a distance cannot be negative: $metres m" }
    }

    // Named factories: each name says which unit its number is in.
    companion object {
        fun fromMetres(metres: Int) = Distance(metres)

        fun fromKilometres(kilometres: Int) = Distance(kilometres * 1000)
    }
}

fun main() {
    val run = Distance.fromKilometres(5)
    val lap = Distance.fromMetres(400)
    println("run: ${run.metres} m, lap: ${lap.metres} m")
    println("laps in the run: ${run.metres / lap.metres}, then ${run.metres % lap.metres} m more")
    try {
        Distance.fromKilometres(-2)
    } catch (error: IllegalArgumentException) {
        println("refused: ${error.message}")
    }
}

In Kotlin: The private constructor and the companion object's factories play the parts of a private constructor and static methods; init checks every new Distance.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

class Distance {
  // Named factories: each name says which unit its number is in.
  Distance.fromMetres(this.metres) {
    if (metres < 0) {
      throw ArgumentError('a distance cannot be negative: $metres m');
    }
  }

  Distance.fromKilometres(int kilometres) : this.fromMetres(kilometres * 1000);

  final int metres;
}

void main() {
  final run = Distance.fromKilometres(5);
  final lap = Distance.fromMetres(400);
  print('run: ${run.metres} m, lap: ${lap.metres} m');
  print(
    'laps in the run: ${run.metres ~/ lap.metres}, then ${run.metres % lap.metres} m more',
  );
  try {
    Distance.fromKilometres(-2);
  } on ArgumentError catch (error) {
    print('refused: ${error.message}');
  }
}

In Dart: Dart writes named factories as named constructors, Distance.fromMetres(…). With no unnamed constructor, Distance(5000) does not compile.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart