References, identity and aliasing

Python 3.14 · main.py

class Card:
    def __init__(self, balance: int) -> None:
        self.balance = balance


def charge_fee(card: Card) -> None:
    card.balance -= 10  # changes the object the caller passed in


def swap_card(card: Card) -> int:
    card = Card(card.balance + 400)  # points this function's own name at a new card
    return card.balance


mine = Card(100)
charge_fee(mine)
print(f"after charge_fee(mine): {mine.balance}")
inside = swap_card(mine)
print(f"swap_card(mine) made a card of {inside}; mine is still {mine.balance}")

alias = mine
twin = Card(mine.balance)
print(f"alias and mine: {'same object' if alias is mine else 'different objects'}")
print(f"twin and mine: {'same object' if twin is mine else 'different objects'}")
print(f"equal balances: {'yes' if twin.balance == mine.balance else 'no'}")

In Python: Python passes arguments by assignment. card is a new name bound to the caller's object, so card = Card(…) rebinds that name only, and is tests identity.

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 Card {
  constructor(balance) {
    this.balance = balance;
  }
}

function chargeFee(card) {
  card.balance -= 10; // changes the object the caller passed in
}

function swapCard(card) {
  card = new Card(card.balance + 400); // points this function's own name at a new card
  return card.balance;
}

const mine = new Card(100);
chargeFee(mine);
console.log(`after charge_fee(mine): ${mine.balance}`);
const inside = swapCard(mine);
console.log(`swap_card(mine) made a card of ${inside}; mine is still ${mine.balance}`);

const alias = mine;
const twin = new Card(mine.balance);
console.log(`alias and mine: ${alias === mine ? "same object" : "different objects"}`);
console.log(`twin and mine: ${twin === mine ? "same object" : "different objects"}`);
console.log(`equal balances: ${twin.balance === mine.balance ? "yes" : "no"}`);

In JavaScript: === on two objects is true only when both sides refer to the same object, whatever their fields hold.

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 {
  static void chargeFee(Card card) {
    card.balance -= 10; // changes the object the caller passed in
  }

  static int swapCard(Card card) {
    card = new Card(card.balance + 400); // points this function's own name at a new card
    return card.balance;
  }

  public static void main(String[] args) {
    Card mine = new Card(100);
    chargeFee(mine);
    System.out.println("after charge_fee(mine): " + mine.balance);
    int inside = swapCard(mine);
    System.out.println(
        "swap_card(mine) made a card of " + inside + "; mine is still " + mine.balance);

    Card alias = mine;
    Card twin = new Card(mine.balance);
    System.out.println("alias and mine: " + (alias == mine ? "same object" : "different objects"));
    System.out.println("twin and mine: " + (twin == mine ? "same object" : "different objects"));
    System.out.println("equal balances: " + (twin.balance == mine.balance ? "yes" : "no"));
  }
}

final class Card {
  int balance;

  Card(int balance) {
    this.balance = balance;
  }
}

In Java: Java passes every argument by value, and for an object the value is a reference. card = new Card(…) changes the parameter, never the caller's variable.

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 <print>

struct Card {
  int balance;
};

void charge_fee(Card *card) {
  card->balance -= 10; // changes the object the caller passed in
}

int swap_card(const Card *card) {
  const Card fresh{card->balance + 400};
  card = &fresh; // points this function's own name at a new card
  return card->balance;
}

int main() {
  Card mine{100};
  charge_fee(&mine);
  std::println("after charge_fee(mine): {}", mine.balance);
  const int inside = swap_card(&mine);
  std::println("swap_card(mine) made a card of {}; mine is still {}", inside,
               mine.balance);

  const Card *alias = &mine;
  const Card twin{mine.balance};
  std::println("alias and mine: {}",
               alias == &mine ? "same object" : "different objects");
  std::println("twin and mine: {}",
               &twin == &mine ? "same object" : "different objects");
  std::println("equal balances: {}",
               twin.balance == mine.balance ? "yes" : "no");
}

In C++: The functions take pointers, which is what Java and Python pass. A reference parameter, Card& card, would be a true alias, and assigning to it would overwrite mine.

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

var mine = new Card(100);
ChargeFee(mine);
Console.WriteLine($"after charge_fee(mine): {mine.Balance}");
int inside = SwapCard(mine);
Console.WriteLine($"swap_card(mine) made a card of {inside}; mine is still {mine.Balance}");

var alias = mine;
var twin = new Card(mine.Balance);
Console.WriteLine($"alias and mine: {Sameness(ReferenceEquals(alias, mine))}");
Console.WriteLine($"twin and mine: {Sameness(ReferenceEquals(twin, mine))}");
Console.WriteLine($"equal balances: {(twin.Balance == mine.Balance ? "yes" : "no")}");

static void ChargeFee(Card card)
{
    card.Balance -= 10; // changes the object the caller passed in
}

static string Sameness(bool same) => same ? "same object" : "different objects";

static int SwapCard(Card card)
{
    card = new Card(card.Balance + 400); // points this function's own name at a new card
    return card.Balance;
}

sealed class Card(int balance)
{
    public int Balance { get; set; } = balance;
}

In C#: The parameter holds a copy of the reference. Declared ref Card card, it would be the caller's variable itself, and card = new Card(…) would replace mine.

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 <stdio.h>

struct card {
  int balance;
};

static void charge_fee(struct card *card) {
  card->balance -= 10; // changes the object the caller passed in
}

static int swap_card(const struct card *card) {
  const struct card fresh = {.balance = card->balance + 400};
  card = &fresh; // points this function's own name at a new card
  return card->balance;
}

int main(void) {
  struct card mine = {.balance = 100};
  charge_fee(&mine);
  printf("after charge_fee(mine): %d\n", mine.balance);
  const int inside = swap_card(&mine);
  printf("swap_card(mine) made a card of %d; mine is still %d\n", inside,
         mine.balance);

  const struct card *alias = &mine;
  const struct card twin = {.balance = mine.balance};
  printf("alias and mine: %s\n",
         alias == &mine ? "same object" : "different objects");
  printf("twin and mine: %s\n",
         &twin == &mine ? "same object" : "different objects");
  printf("equal balances: %s\n", twin.balance == mine.balance ? "yes" : "no");
  return 0;
}

In C: C passes the pointer itself by value, so card = &fresh changes only the copy inside swap_card, and comparing pointers is the identity test.

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 Card
{
    public function __construct(public int $balance) {}
}

function chargeFee(Card $card): void
{
    $card->balance -= 10; // changes the object the caller passed in
}

function swapCard(Card $card): int
{
    $card = new Card($card->balance + 400); // points this function's own name at a new card

    return $card->balance;
}

$mine = new Card(100);
chargeFee($mine);
echo "after charge_fee(mine): {$mine->balance}\n";
$inside = swapCard($mine);
echo "swap_card(mine) made a card of {$inside}; mine is still {$mine->balance}\n";

$alias = $mine;
$twin = new Card($mine->balance);
echo 'alias and mine: ' . ($alias === $mine ? 'same object' : 'different objects') . "\n";
echo 'twin and mine: ' . ($twin === $mine ? 'same object' : 'different objects') . "\n";
echo 'equal balances: ' . ($twin->balance === $mine->balance ? 'yes' : 'no') . "\n";

In PHP: The parameter receives a copy of the object's identifier. PHP's &$card would pass the caller's variable itself, like a C++ reference.

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 Card {
    balance: i32,
}

fn charge_fee(card: &mut Card) {
    card.balance -= 10; // changes the object the caller passed in
}

fn swap_card(card: &Card) -> i32 {
    let fresh = Card {
        balance: card.balance + 400,
    };
    let card = &fresh; // points this function's own name at a new card
    card.balance
}

fn main() {
    let mut mine = Card { balance: 100 };
    charge_fee(&mut mine);
    println!("after charge_fee(mine): {}", mine.balance);
    let inside = swap_card(&mine);
    println!(
        "swap_card(mine) made a card of {inside}; mine is still {}",
        mine.balance
    );

    let alias = &mine;
    let twin = Card {
        balance: mine.balance,
    };
    let same = |x: &Card| {
        if std::ptr::eq(x, &mine) {
            "same object"
        } else {
            "different objects"
        }
    };
    println!("alias and mine: {}", same(alias));
    println!("twin and mine: {}", same(&twin));
    let equal = if twin.balance == mine.balance {
        "yes"
    } else {
        "no"
    };
    println!("equal balances: {equal}");
}

In Rust: A borrowed parameter cannot point at a value made inside the function, so swap_card shadows card with a new binding to fresh. std::ptr::eq compares addresses.

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 Card {
  balance: number;

  constructor(balance: number) {
    this.balance = balance;
  }
}

function chargeFee(card: Card): void {
  card.balance -= 10; // changes the object the caller passed in
}

function swapCard(card: Card): number {
  card = new Card(card.balance + 400); // points this function's own name at a new card
  return card.balance;
}

const mine = new Card(100);
chargeFee(mine);
console.log(`after charge_fee(mine): ${mine.balance}`);
const inside = swapCard(mine);
console.log(`swap_card(mine) made a card of ${inside}; mine is still ${mine.balance}`);

const alias = mine;
const twin = new Card(mine.balance);
console.log(`alias and mine: ${alias === mine ? "same object" : "different objects"}`);
console.log(`twin and mine: ${twin === mine ? "same object" : "different objects"}`);
console.log(`equal balances: ${twin.balance === mine.balance ? "yes" : "no"}`);

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 Card struct {
	balance int
}

func chargeFee(card *Card) {
	card.balance -= 10 // changes the object the caller passed in
}

func swapCard(card *Card) int {
	card = &Card{balance: card.balance + 400} // points this function's own name at a new card
	return card.balance
}

func sameOrNot(same bool) string {
	if same {
		return "same object"
	}
	return "different objects"
}

func main() {
	mine := &Card{balance: 100}
	chargeFee(mine)
	fmt.Printf("after charge_fee(mine): %d\n", mine.balance)
	inside := swapCard(mine)
	fmt.Printf("swap_card(mine) made a card of %d; mine is still %d\n", inside, mine.balance)

	alias := mine
	twin := &Card{balance: mine.balance}
	fmt.Printf("alias and mine: %s\n", sameOrNot(alias == mine))
	fmt.Printf("twin and mine: %s\n", sameOrNot(twin == mine))
	equal := "no"
	if twin.balance == mine.balance {
		equal = "yes"
	}
	fmt.Printf("equal balances: %s\n", equal)
}

In Go: Go passes everything by value, so card is a copy of the caller's pointer and pointing it at a new Card leaves mine alone. == on pointers tests identity.

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 Card {
  var balance: Int

  init(balance: Int) {
    self.balance = balance
  }
}

func chargeFee(_ card: Card) {
  card.balance -= 10  // changes the object the caller passed in
}

func swapCard(_ card: Card) -> Int {
  var card = card
  card = Card(balance: card.balance + 400)  // points this function's own name at a new card
  return card.balance
}

let mine = Card(balance: 100)
chargeFee(mine)
print("after charge_fee(mine): \(mine.balance)")
let inside = swapCard(mine)
print("swap_card(mine) made a card of \(inside); mine is still \(mine.balance)")

let alias = mine
let twin = Card(balance: mine.balance)
print("alias and mine: \(alias === mine ? "same object" : "different objects")")
print("twin and mine: \(twin === mine ? "same object" : "different objects")")
print("equal balances: \(twin.balance == mine.balance ? "yes" : "no")")

In Swift: Card is a class here, so it is shared. Parameters are constants, so swapCard copies the reference into var card before pointing it elsewhere; === tests identity.

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 card that holds a balance.
class Card
  attr_accessor :balance

  def initialize(balance)
    @balance = balance
  end
end

def charge_fee(card)
  card.balance -= 10 # changes the object the caller passed in
end

def swap_card(card)
  card = Card.new(card.balance + 400) # points this function's own name at a new card
  card.balance
end

mine = Card.new(100)
charge_fee(mine)
puts "after charge_fee(mine): #{mine.balance}"
inside = swap_card(mine)
puts "swap_card(mine) made a card of #{inside}; mine is still #{mine.balance}"

alias_name = mine
twin = Card.new(mine.balance)
puts "alias and mine: #{alias_name.equal?(mine) ? 'same object' : 'different objects'}"
puts "twin and mine: #{twin.equal?(mine) ? 'same object' : 'different objects'}"
puts "equal balances: #{twin.balance == mine.balance ? 'yes' : 'no'}"

In Ruby: Ruby passes references by value, as Python does. alias is a keyword in Ruby, so the second name is alias_name, and equal? tests identity.

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 Card(
    var balance: Int,
)

fun chargeFee(card: Card) {
    card.balance -= 10 // changes the object the caller passed in
}

fun swapCard(card: Card): Int {
    var current = card
    current = Card(current.balance + 400) // points this function's own name at a new card
    return current.balance
}

fun main() {
    val mine = Card(100)
    chargeFee(mine)
    println("after charge_fee(mine): ${mine.balance}")
    val inside = swapCard(mine)
    println("swap_card(mine) made a card of $inside; mine is still ${mine.balance}")

    val alias = mine
    val twin = Card(mine.balance)
    println("alias and mine: ${if (alias === mine) "same object" else "different objects"}")
    println("twin and mine: ${if (twin === mine) "same object" else "different objects"}")
    println("equal balances: ${if (twin.balance == mine.balance) "yes" else "no"}")
}

In Kotlin: Parameters are read-only, so swapCard copies the reference into var current before pointing it at a new card. === tests identity and == equality.

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 Card {
  Card(this.balance);

  int balance;
}

void chargeFee(Card card) {
  card.balance -= 10; // changes the object the caller passed in
}

int swapCard(Card card) {
  card = Card(
    card.balance + 400,
  ); // points this function's own name at a new card
  return card.balance;
}

void main() {
  final mine = Card(100);
  chargeFee(mine);
  print('after charge_fee(mine): ${mine.balance}');
  final inside = swapCard(mine);
  print(
    'swap_card(mine) made a card of $inside; mine is still ${mine.balance}',
  );

  final alias = mine;
  final twin = Card(mine.balance);
  print(
    'alias and mine: ${identical(alias, mine) ? 'same object' : 'different objects'}',
  );
  print(
    'twin and mine: ${identical(twin, mine) ? 'same object' : 'different objects'}',
  );
  print('equal balances: ${twin.balance == mine.balance ? 'yes' : 'no'}');
}

In Dart: Reassigning a parameter changes only the function's own variable. identical() tests whether two references point to one object.

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