Prototype Pattern in Go

I. Prototype Pattern — Creational Pattern

The Prototype pattern specifies the kinds of objects to create using a prototypical instance, and creates new objects by cloning that prototype.

Instead of building a new object from scratch every time, you start from a pre-built, fully-initialized instance and copy it. The clone is then free to be modified independently — mutations to the copy never affect the original prototype.

When to use it:

• Object initialization is expensive (database lookups, file reads, complex calculations)

• You need many objects that differ only in a few fields

• You want to avoid subclassing just to configure objects differently

• The class to instantiate is only known at runtime

II. Real-world Example

Imagine a web page generator. Every page on the site shares one of two layouts:

1. MainLayout — includes a nav header, content body, and copyright footer. Building it is expensive (reads config, sets defaults).

2. BlankLayout — an empty layout with no header or footer, used for login/error pages.

Instead of re-building MainLayout for every new page, we keep a single cached instance (MainLayoutIns) and clone it each time NewPage() is called. Each Page gets its own independent copy — mutations to one page's layout never bleed into another.

III. Implementation

Layout struct

1// layout.go
2package prototype
3
4type Layout struct {
5    Header string
6    Body   string
7    Footer string
8}

Singleton prototypes

1// layout.go
2package prototype
3
4const (
5    BLANK_LAYOUT = iota + 1
6    MAIN_LAYOUT
7)
8
9var BlankLayoutIns = Layout{
10    Header: "",
11    Body:   "",
12    Footer: "",
13}
14
15var MainLayoutIns = Layout{
16    Header: "<nav>Main navigation menu</nav>",
17    Body:   "",
18    Footer: "<footer>Copyright 2026</footer>",
19}

cloneLayout — the copy function

1// layout.go
2package prototype
3
4func cloneLayout(l int) Layout {
5    switch l {
6    case BLANK_LAYOUT:
7        copy := BlankLayoutIns
8        return copy
9    case MAIN_LAYOUT:
10        copy := MainLayoutIns
11        return copy
12    default:
13        return Layout{}
14    }
15}

In Go, assigning a struct to a new variable produces a value copy — all fields are duplicated. This is the prototype clone in action.

Page struct and NewPage constructor

1// page.go
2package prototype
3
4type Page struct {
5    Layout
6    URI string
7}
8
9func NewPage(uri string, layoutType int) Page {
10    return Page{
11        Layout: cloneLayout(layoutType),
12        URI:    uri,
13    }
14}

IV. Explain the Example Above

Let's trace the execution step by step:

Step 1 — Create a page with MainLayout:

1homePage := NewPage("/home", MAIN_LAYOUT)
2// cloneLayout(MAIN_LAYOUT) copies MainLayoutIns into a new Layout value
3// homePage.Header = "<nav>Main navigation menu</nav>"
4// homePage.Footer = "<footer>Copyright 2026</footer>"

Step 2 — Create another page with the same layout:

profilePage := NewPage("/profile", MAIN_LAYOUT)

Step 3 — Mutate one page's layout without affecting the other:

1homePage.Header = "<nav>Home-specific banner</nav>"
2
3fmt.Println(homePage.Header)    // "<nav>Home-specific banner</nav>"
4fmt.Println(profilePage.Header) // "<nav>Main navigation menu</nav>" — unchanged
5fmt.Println(MainLayoutIns.Header) // "<nav>Main navigation menu</nav>" — prototype untouched

Output:

1/home    header: <nav>Home-specific banner</nav>
2/profile header: <nav>Main navigation menu</nav>

This demonstrates the key property: each call to NewPage() produces a fully independent copy. The MainLayoutIns singleton is never modified.

BlankLayout for login page:

1loginPage := NewPage("/login", BLANK_LAYOUT)
2fmt.Println(loginPage.Header) // ""
3fmt.Println(loginPage.Footer) // ""

V. Conclusion

The Prototype pattern is elegant when object creation cost is the bottleneck. In Go, the pattern maps naturally to struct assignment — there's no need for a Clone() interface unless you're working with pointer fields that require deep copying.

Key takeaways:

• Go struct assignment is a shallow copy — sufficient when all fields are value types (strings, ints, bools)

• If your struct contains slices, maps, or pointers, you need an explicit deep copy function

• Singleton prototypes + clone = cache the expensive initialization once, reuse forever

Compared to other creational patterns:

• Builder — constructs objects step by step from scratch

• Factory Method — delegates creation to a function/subclass

• Prototype — copies an existing, pre-initialized instance

As with all design patterns, no pattern is universally superior. Prototype is most valuable when initialization cost dominates and your objects share a common starting state.

VI. References

• Book: Go Design Patterns by Mario Castro Contreras

• Source code: github.com/khaaleoo/golang-design-patterns/tree/main/creational-patterns/prototype

• Related posts:
• Builder Pattern in Go
• Factory Method Pattern in Go
• Abstract Factory Pattern in Go
• Proxy Pattern in Go