gof-singleton-pattern

name: gof-singleton-pattern description: Implements the Singleton design pattern ensuring a class has only one instance while providing a global point of access to it. license: MIT compatibility: opencode metadata: version: "1.0.0" domain: architecture triggers: singleton pattern, ensure single instance, global access, gof patterns archetypes:

educational anti_triggers:
brainstorming
vague ideation response_profile: verbosity: low directive_strength: high abstraction_level: operational role: implementation scope: implementation output-format: code related-skills: gof-factory-pattern, gof-strategy-pattern

Singleton Pattern

archetypes: implementation, educational anti_triggers: allowing multiple instances response_profile: verbosity: medium directive_strength: high abstraction_level: tactical

Implements the Singleton design pattern ensuring a class has only one instance while providing a global point of access to it.

When to Use

The When to Use section should detail under what circumstances this skill is applicable by incorporating the following:

Archetypes

Implementation: Aims to guide developers in implementing the Singleton pattern effectively.
Educational: Educates the user on the implications and benefits of the Singleton pattern in their projects.

Anti-Triggers

Allowing multiple instances: This skill should avoid contexts where discussions around multiple instances occur without justification.

Response Profile

Verbosity: Medium
Directive Strength: High
Abstraction Level: Tactical
When exactly one instance of a class is needed.
When it’s critical to control the access to that instance globally.
When the instance should run in a multithreaded environment without data corruption.

Core Workflow

Define the Class: Create a private constructor to prevent direct initialization.
Static Method: Implement a static method that provides access to the instance, creating it if necessary.
Provide Thread Safety: Ensure the method is thread-safe to prevent multiple instances in concurrent environments.

Implementation Patterns

Thread-Safe Singleton Pattern

package main

import (
    "sync"
)

type singleton struct {
    // example resource
    resource string
}

var instance *singleton
var once sync.Once

// GetInstance returns the single instance of the singleton class
func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{resource: "Initialized Resource"}
    })
    return instance
}

Example Usage

package main

import (
    "fmt"
)

func main() {
    firstInstance := GetInstance()
    fmt.Println(firstInstance.resource)  // Output: Initialized Resource

    secondInstance := GetInstance()
    fmt.Println(firstInstance == secondInstance)  // Output: true
}