Prototype: create objects by copying

Java · compiled/Templates.java

// Prototype in Java 25: what Object.clone() shares, and a copy constructor that decides field
// by field.
// Run: java Templates.java
import java.util.ArrayList;
import java.util.List;

public class Templates {
    record Style(String font, String accent) {} // immutable, so copies may share it

    // 1. Cloneable: Object.clone() fills the new object's fields "as if by assignment", so the
    //    list is shared.
    static class CloneableTemplate implements Cloneable {
        final Style style;
        // final: clone() cannot even replace it with a copy
        final List<String> lines = new ArrayList<>();

        CloneableTemplate(Style style) {
            this.style = style;
        }

        @Override
        public CloneableTemplate clone() {
            try {
                return (CloneableTemplate) super.clone();
            } catch (CloneNotSupportedException e) {
                throw new AssertionError(e);
            }
        }
    }

    // 2. A copy constructor: copy what can change, share what cannot.
    static final class Template {
        final Style style;
        final List<String> lines;

        Template(Style style) {
            this.style = style;
            this.lines = new ArrayList<>();
        }

        Template(Template prototype) {
            this.style = prototype.style;
            this.lines = new ArrayList<>(prototype.lines);
        }
    }

    public static void main(String[] args) {
        Style house = new Style("Inter", "teal");

        CloneableTemplate first = new CloneableTemplate(house);
        CloneableTemplate firstCopy = first.clone();
        firstCopy.lines.add("mug");
        boolean sameList = firstCopy.lines == first.lines;
        int firstLines = first.lines.size();
        System.out.println("Object.clone():   the prototype now has " + firstLines + " line;"
                + " same list: " + sameList);

        Template second = new Template(house);
        Template secondCopy = new Template(second);
        secondCopy.lines.add("mug");
        boolean shared = secondCopy.style == second.style;
        int secondLines = second.lines.size();
        System.out.println("copy constructor: the prototype keeps " + secondLines + " lines;"
                + " style shared: " + shared);
    }
}

TypeScript · compiled/templates.ts

// Prototype in TypeScript: structuredClone copies data but not the class; a spread copy is
// shallow; an explicit clone() method keeps the class and copies what can change.
// Run: node templates.ts
interface Style {
  readonly font: string;
  readonly accent: string;
}

class Template {
  readonly style: Style;
  lines: string[];

  constructor(style: Style, lines: string[] = []) {
    this.style = style;
    this.lines = lines;
  }

  count(): number {
    return this.lines.length;
  }

  clone(): Template {
    // a new list; the immutable style is shared
    return new Template(this.style, [...this.lines]);
  }
}

const house: Style = Object.freeze({ font: "Inter", accent: "teal" });

const a = new Template(house, ["kettle"]);
const structured = structuredClone(a);
const isTemplate = structured instanceof Template;
const kept = `instanceof Template: ${isTemplate}; count(): ${typeof structured.count}`;
console.log(`structuredClone: lines ${JSON.stringify(structured.lines)}; ${kept}`);

const b = new Template(house, ["kettle"]);
const spread = { ...b };
spread.lines.push("mug");
const spreadShares = spread.style === b.style;
const spreadLines = b.count();
console.log(
  `spread copy:     the prototype now has ${spreadLines} lines; style shared: ${spreadShares}`,
);

const c = new Template(house, ["kettle"]);
const cloned = c.clone();
cloned.lines.push("mug");
const cloneShares = cloned.style === c.style;
const facts = `instanceof Template: ${cloned instanceof Template}; style shared: ${cloneShares}`;
console.log(`clone():         the prototype keeps ${c.count()} line; ${facts}`);

Go · compiled/templates.go

// Prototype in Go: struct assignment copies a map or slice header, not its contents; maps.Clone
// and slices.Clone copy one level; an explicit Clone method decides what to copy.
// Run: go run templates.go
package main

import (
	"fmt"
	"maps"
	"slices"
)

type Style struct{ Font, Accent string }

type Template struct {
	Style  *Style // shared on purpose: nothing changes it
	Fields map[string]string
	Lines  []string
}

func (t *Template) Clone() *Template {
	return &Template{Style: t.Style, Fields: maps.Clone(t.Fields), Lines: slices.Clone(t.Lines)}
}

func prototype(style *Style) *Template {
	return &Template{
		Style:  style,
		Fields: map[string]string{"title": "Tax invoice"},
		Lines:  []string{"kettle"},
	}
}

func main() {
	house := &Style{"Inter", "teal"}

	p := prototype(house)
	shallow := *p // copies the struct: the map and the slice's backing array are shared
	shallow.Fields["title"] = "Receipt"
	shallow.Lines[0] = "mug"
	fmt.Printf("struct assignment: the prototype's title is now %q and its first line %q\n",
		p.Fields["title"], p.Lines[0])

	q := prototype(house)
	deep := q.Clone()
	deep.Fields["title"] = "Receipt"
	deep.Lines = append(deep.Lines, "mug")
	fmt.Printf("Clone():           the prototype keeps %q and %d line; style shared: %v\n",
		q.Fields["title"], len(q.Lines), deep.Style == q.Style)

	nested := map[string][]string{"lines": {"kettle"}}
	copied := maps.Clone(nested)
	copied["lines"][0] = "mug"
	fmt.Printf("maps.Clone:        a slice inside the cloned map is still shared: %q\n",
		nested["lines"][0])
}

C++ · compiled/templates.cpp

// Prototype in C++23: copying a derived object through a base reference slices it; a virtual
// clone() returns a complete copy as std::unique_ptr (C++ Core Guidelines C.67, C.130). The
// style is shared through shared_ptr<const>.
// Build: clang++ -std=c++23 -Wall -Wextra -fsanitize=address,undefined templates.cpp -o templates
#include <format>
#include <memory>
#include <print>
#include <string>
#include <utility>
#include <vector>

struct Style {
    std::string font, accent;
};

std::string count(std::size_t n) {
    return std::format("{} line{}", n, n == 1 ? "" : "s");
}

class Document {
public:
    explicit Document(std::shared_ptr<const Style> style) : style_{std::move(style)} {}
    virtual ~Document() = default;
    // public here, so the slicing below compiles; C.67 would make it protected
    Document(const Document&) = default;
    Document& operator=(const Document&) = delete;

    virtual std::string describe() const { return "document, " + count(lines.size()); }
    virtual std::unique_ptr<Document> clone() const {
        return std::make_unique<Document>(*this);
    }
    const std::shared_ptr<const Style>& style() const { return style_; }

    std::vector<std::string> lines;

private:
    std::shared_ptr<const Style> style_;
};

class Invoice final : public Document {
public:
    Invoice(std::shared_ptr<const Style> style, std::string number)
        : Document{std::move(style)}, number_{std::move(number)} {}

    std::string describe() const override {
        return "invoice " + number_ + ", " + count(lines.size());
    }
    std::unique_ptr<Document> clone() const override {
        return std::make_unique<Invoice>(*this);
    }

private:
    std::string number_;
};

int main() {
    auto house = std::make_shared<const Style>(Style{"Inter", "teal"});
    Invoice prototype{house, "INV-1042"};
    prototype.lines.push_back("kettle");
    const Document& any = prototype;

    Document sliced = any;  // copies only the Document part of the Invoice
    std::println("copied through Document&: {}", sliced.describe());

    auto copy = any.clone();  // the virtual call reaches Invoice::clone()
    copy->lines.push_back("mug");
    std::println("clone():                  {}", copy->describe());
    std::println("the prototype keeps {} line; style shared: {}", prototype.lines.size(),
                 copy->style() == prototype.style());
}

Rust · compiled/templates.rs

// Prototype in Rust: #[derive(Clone)] copies what the value owns (a Vec, a String) and shares
// what sits behind an Rc, including any RefCell inside it.
// Build: rustc --edition 2024 templates.rs
use std::cell::RefCell;
use std::rc::Rc;

struct Style {
    font: String,
}

#[derive(Clone)]
struct Template {
    style: Rc<Style>,                // shared on purpose: immutable
    lines: Vec<String>,              // owned: each clone gets its own
    notes: Rc<RefCell<Vec<String>>>, // shared and changeable: every clone sees every change
}

fn main() {
    let prototype = Template {
        style: Rc::new(Style {
            font: "Inter".to_string(),
        }),
        lines: vec!["kettle".to_string()],
        notes: Rc::new(RefCell::new(Vec::new())),
    };

    let mut copy = prototype.clone();
    copy.lines.push("mug".to_string());
    println!(
        "derive(Clone): the prototype keeps {} line; style shared: {} ({} owners of the {} style)",
        prototype.lines.len(),
        Rc::ptr_eq(&prototype.style, &copy.style),
        Rc::strong_count(&prototype.style),
        copy.style.font
    );

    copy.notes.borrow_mut().push("fragile".to_string());
    println!(
        "a RefCell behind an Rc is shared too: the prototype's notes are now {:?}",
        prototype.notes.borrow()
    );
}

compiled/languages_session.py

from session import run, versions

# What each language's copy facility copies and what it shares, run with the pinned toolchains.
versions("javac --version", "node --version", "go version", "clang++ --version", "rustc --version")
run("""
java Templates.java
node templates.ts
go run templates.go
clang++ -std=c++23 -O1 -g -Wall -Wextra -fsanitize=address,undefined templates.cpp -o templates
./templates
rustc --edition 2024 -o templates_rs templates.rs && ./templates_rs
""")

# javac 25.0.4.1
# v24.21.0
# go version go1.27.1 darwin/arm64
# Apple clang version 21.0.0 (clang-2100.3.34.2)
# rustc 1.99.0 (b940084d7)
$ java Templates.java
Object.clone():   the prototype now has 1 line; same list: true
copy constructor: the prototype keeps 0 lines; style shared: true
$ node templates.ts
structuredClone: lines ["kettle"]; instanceof Template: false; count(): undefined
spread copy:     the prototype now has 2 lines; style shared: true
clone():         the prototype keeps 1 line; instanceof Template: true; style shared: true
$ go run templates.go
struct assignment: the prototype's title is now "Receipt" and its first line "mug"
Clone():           the prototype keeps "Tax invoice" and 1 line; style shared: true
maps.Clone:        a slice inside the cloned map is still shared: "mug"
$ clang++ -std=c++23 -O1 -g -Wall -Wextra -fsanitize=address,undefined templates.cpp -o templates
$ ./templates
copied through Document&: document, 1 line
clone():                  invoice INV-1042, 2 lines
the prototype keeps 1 line; style shared: true
$ rustc --edition 2024 -o templates_rs templates.rs && ./templates_rs
derive(Clone): the prototype keeps 1 line; style shared: true (2 owners of the Inter style)
a RefCell behind an Rc is shared too: the prototype's notes are now ["fragile"]

compiled/session.py

"""Prints a terminal session: "$ " and each command, then everything it printed (standard output
and standard error together), and its exit status when that is not 0.

The toolchains are the pinned ones: Java 25 (Eclipse Temurin 25.0.4), Node.js 24.21.0 and Go
1.27.1 from the mise installations next to the Python that runs this file, Rust 1.99.0 from
its rustup toolchain, and the system's Apple clang. learn:verify cannot let a sandboxed run
read the home folder those installations live in, so the sessions of this folder are recorded
with LEARN_VERIFY_NETWORK=allow. They read only this folder and the toolchains, write only
inside this folder and the run's own temporary home, and never use the network.

A command that fails and is not listed in expect_failure makes the session exit with status
1, so a run that could not build a program never becomes a record."""

import os
import pwd
import re
import signal
import subprocess
import sys
from pathlib import Path

# .../installs/python/3.14.8/bin/python3 -> .../installs
INSTALLS = Path(sys.executable).resolve().parents[3]
REAL_HOME = Path(pwd.getpwuid(os.getuid()).pw_dir)
TOOLCHAINS = [
    INSTALLS / "java" / "temurin-25.0.4+101.0.LTS" / "bin",
    INSTALLS / "node" / "24.21.0" / "bin",
    INSTALLS / "go" / "1.27.1" / "bin",
    REAL_HOME / ".rustup" / "toolchains" / "1.99.0-aarch64-apple-darwin" / "bin",
]
# Version lines that end with a build date (rustc's) are shown without it: pages show no dates.
BUILD_DATE = re.compile(r"\s+\d{4}-\d{2}-\d{2}(?=\))")


def _env() -> dict[str, str]:
    env = dict(os.environ)
    env["PATH"] = os.pathsep.join([*map(str, TOOLCHAINS), env.get("PATH", "")])
    env["GOTOOLCHAIN"] = "local"  # never download another Go
    env["GOTELEMETRY"] = "off"
    env["GOFLAGS"] = "-trimpath"
    return env


def _shell(command: str) -> subprocess.CompletedProcess[str]:
    return subprocess.run(
        command, shell=True, env=_env(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
    )


def versions(*commands: str) -> None:
    """Prints the first line of each version command as a comment."""
    for command in commands:
        done = _shell(command)
        lines = done.stdout.splitlines()
        if done.returncode != 0 or not lines:
            sys.exit(f"{command} did not run: the pinned toolchain is missing here")
        print("#", BUILD_DATE.sub("", lines[0]))


def run(script: str, expect_failure: tuple[str, ...] = ()) -> None:
    """Runs each line of the script as one shell command; only the commands in expect_failure
    may fail."""
    failed = 0
    for command in (line.strip() for line in script.strip().splitlines()):
        print(f"$ {command}")
        done = _shell(command)
        print(done.stdout, end="")
        if done.returncode < 0:
            print(f"[stopped by signal {signal.Signals(-done.returncode).name}]")
        elif done.returncode != 0:
            print(f"[exit status {done.returncode}]")
        if done.returncode != 0 and command not in expect_failure:
            failed += 1
    if failed:
        sys.exit(1)