Prototype Design Pattern

public final class ReportTemplate implements Cloneable {
    private final Layout layout;                 // immutable — safe to share
    private final Map<String, Style> styles;     // mutable  — must be copied
    private String logo;
    private String currency;

    public ReportTemplate(Path spec) {
        this.layout = LayoutParser.parse(spec);      // the expensive part
        this.styles = StyleSheet.compile(spec);
    }

    // Copy constructor rather than Object.clone(): explicit, works with final
    // fields, and doesn't drag in the Cloneable/CloneNotSupportedException mess.
    private ReportTemplate(ReportTemplate other) {
        this.layout   = other.layout;                       // shared: immutable
        this.styles   = new HashMap<>(other.styles);        // copied: mutable
        this.logo     = other.logo;
        this.currency = other.currency;
    }

    public ReportTemplate copy() { return new ReportTemplate(this); }

    public ReportTemplate withLogo(String logo) {
        ReportTemplate c = copy();
        c.logo = logo;
        return c;
    }
}

// ReportTemplate base = new ReportTemplate(Path.of("invoice.spec"));  // once
// ReportTemplate acme = base.withLogo("acme.png");                    // free
//
// Effective Java is blunt about java.lang.Cloneable: prefer a copy constructor
// or a static copy factory. Object.clone() bypasses constructors and interacts
// badly with final fields.

import copy
from dataclasses import dataclass, field, replace


@dataclass
class ReportTemplate:
    layout: Layout                       # immutable — safe to share
    styles: dict[str, Style]             # mutable  — must be copied
    logo: str = ""
    currency: str = "USD"

    @classmethod
    def parse(cls, spec: Path) -> "ReportTemplate":
        return cls(layout=parse_layout(spec), styles=compile_styles(spec))

    def clone(self, **overrides) -> "ReportTemplate":
        # Choose the depth per field rather than reaching for deepcopy(self):
        # layout is expensive AND immutable, so copying it would be pure waste.
        return replace(
            self,
            styles=copy.deepcopy(self.styles),
            **overrides,
        )


base = ReportTemplate.parse(Path("invoice.spec"))   # once
acme = base.clone(logo="acme.png")                  # free

# copy.copy() is shallow, copy.deepcopy() recurses the whole graph and handles
# cycles. deepcopy is correct-by-default and can be dramatically slower than
# the parse you were trying to avoid — measure before assuming it's a win.
# Customise per class with __deepcopy__ when it matters.

class ReportTemplate {
public:
    static ReportTemplate parse(const std::filesystem::path& spec) {
        return ReportTemplate(parse_layout(spec), compile_styles(spec));
    }

    // Virtual clone ("virtual constructor"): callers holding a base pointer can
    // copy the real derived type without knowing what it is.
    [[nodiscard]] virtual std::unique_ptr<ReportTemplate> clone() const {
        return std::make_unique<ReportTemplate>(*this);
    }

    virtual ~ReportTemplate() = default;

private:
    // shared_ptr to a const layout: every clone shares the expensive immutable
    // graph, and the copy constructor only has to bump a refcount.
    std::shared_ptr<const Layout> layout_;
    std::map<std::string, Style> styles_;   // value member -> deep-copied for free
    std::string logo_, currency_;
};

// The default copy constructor already does the right thing here, because the
// members were chosen to have the right copy semantics: shared_ptr shares,
// std::map copies. Getting the member types right is most of the work.

public sealed class ReportTemplate
{
    public Layout Layout { get; private init; } = null!;        // immutable, shared
    public Dictionary<string, Style> Styles { get; private init; } = new();
    public string Logo { get; init; } = "";
    public string Currency { get; init; } = "USD";

    public static ReportTemplate Parse(string spec) => new()
    {
        Layout = LayoutParser.Parse(spec),      // the expensive part
        Styles = StyleSheet.Compile(spec),
    };

    public ReportTemplate Clone() => new()
    {
        Layout = Layout,                                    // shared
        Styles = new Dictionary<string, Style>(Styles),     // copied
        Logo = Logo,
        Currency = Currency,
    };
}

// If ReportTemplate were a `record`, `with` gives you a SHALLOW copy for free:
//
//     var acme = baseTemplate with { Logo = "acme.png" };
//
// Convenient and fast — but note that Styles would then be the SAME dictionary
// in both, so mutating the clone's styles mutates the prototype's.
// MemberwiseClone() has exactly the same caveat.

class ReportTemplate {
  static parse(spec) {
    const t = new ReportTemplate()
    t.layout = parseLayout(spec)      // the expensive part
    t.styles = compileStyles(spec)
    t.logo = ''
    t.currency = 'USD'
    return t
  }

  clone(overrides = {}) {
    const copy = Object.create(ReportTemplate.prototype)
    copy.layout = this.layout                       // shared: immutable
    copy.styles = structuredClone(this.styles)      // copied: mutable
    return Object.assign(copy, { logo: this.logo, currency: this.currency }, overrides)
  }
}

const base = ReportTemplate.parse('invoice.spec')   // once
const acme = base.clone({ logo: 'acme.png' })       // free

// Three copy tools, three depths:
//   { ...obj }            shallow — nested objects are SHARED
//   structuredClone(obj)  deep, handles cycles, but drops functions and class
//                         identity (the result is a plain object)
//   JSON.parse(JSON.stringify(obj))  deep-ish — silently destroys Date, Map,
//                         Set, undefined and BigInt. Avoid.
//
// JavaScript is the one language here that is prototypal all the way down:
// Object.create(proto) is this pattern built into the object model.

package report

// Go has no clone() convention and no copy constructors, so this is explicit —
// which is arguably the honest version, since the copy depth is right there.

type Template struct {
	Layout   *Layout           // immutable after parse — safe to share
	Styles   map[string]Style  // reference type: MUST be copied by hand
	Logo     string
	Currency string
}

func Parse(spec string) (*Template, error) {
	layout, err := parseLayout(spec) // the expensive part
	if err != nil {
		return nil, err
	}
	return &Template{Layout: layout, Styles: compileStyles(spec), Currency: "USD"}, nil
}

// Clone returns a copy that is safe to mutate independently.
func (t *Template) Clone() *Template {
	cp := *t // struct copy: cheap, but maps/slices/pointers are still SHARED
	cp.Styles = make(map[string]Style, len(t.Styles))
	for k, v := range t.Styles {
		cp.Styles[k] = v
	}
	return &cp
}

// base, _ := report.Parse("invoice.spec")   // once
// acme := base.Clone(); acme.Logo = "acme.png"
//
// `cp := *t` is the trap: it looks like a full copy and compiles fine, but
// every map, slice, channel and pointer field is still shared with the
// original. maps.Clone and slices.Clone (Go 1.21+) handle one level each.

interface Style { readonly font: string; readonly size: number }

export class ReportTemplate {
  private constructor(
    readonly layout: Layout,
    readonly styles: ReadonlyMap<string, Style>,
    readonly logo = '',
    readonly currency = 'USD',
  ) {}

  static parse(spec: string): ReportTemplate {
    return new ReportTemplate(parseLayout(spec), compileStyles(spec))
  }

  // Partial<> types the overrides, so `clone({ logoo: 'x' })` is a compile
  // error rather than a silently ignored property.
  clone(overrides: Partial<Pick<ReportTemplate, 'logo' | 'currency'>> = {}): ReportTemplate {
    return new ReportTemplate(
      this.layout,                       // shared: immutable
      new Map(this.styles),              // copied: one level is enough here,
                                         // because Style itself is readonly
      overrides.logo ?? this.logo,
      overrides.currency ?? this.currency,
    )
  }
}

// TypeScript's real contribution to this pattern is `readonly`: once a field is
// genuinely immutable in the type system, you can share it between clones with
// confidence instead of deep-copying it defensively.