genstruct ¶

Overview ¶

Golang library for generating static structs, with a focus on performance.

Public Docs: https://conneroisu.github.io/genstruct/ Pkg Docs: https://godoc.org/github.com/conneroisu/genstruct

The Problem ¶

Static data in Go applications often presents several challenges:

1. Runtime Overhead: Loading data from external sources (JSON, YAML, databases) at runtime adds latency and complexity
2. Type Safety: External data formats lack compile-time type checking, leading to potential runtime errors
3. IDE Support: External data doesn’t benefit from IDE features like autocompletion, refactoring, and documentation
4. Testing: External data makes tests more complex and harder to reason about
5. Deployment: External data files need to be packaged and deployed alongside your application
6. Relationships: Managing relationships between different data types becomes manual and error-prone

The Solution ¶

Genstruct addresses these challenges by moving data from external sources into Go code:

Compile-Time Verification ¶

By generating Go code, all data is verified at compile-time:

• Type errors are caught before your application runs
• Syntax or format errors become impossible
• Missing or malformed data is immediately apparent

Performance Benefits ¶

Static data compilation provides significant performance advantages:

• No runtime loading or parsing overhead
• Zero allocation overhead compared to unmarshaling JSON/YAML
• Instant access to data without initialization code
• Reduced memory usage (no map-based intermediate structures)

Developer Experience ¶

The development experience is dramatically improved:

• Full IDE support with autocompletion
• Jump-to-definition for data references
• Inline documentation for data structures
• Simplified refactoring and renaming
• Consistent code structure for both logic and data

Relationships Between Data ¶

With the struct reference embedding feature:

• Relationships between different data types are automatically managed
• References maintain type safety and refactoring support
• Data consistency is enforced at compile time
• Changes to reference fields are tracked through the type system

When to Use Genstruct ¶

Genstruct is ideal for applications that have:

1. Reference Data: Lists of countries, categories, permissions, etc.
2. Configuration Constants: Feature flags, limits, defaults
3. Enumerated Types: Status values, types, classifications
4. Content Libraries: Help content, error messages, documentation
5. Related Data: Blog posts with tags, products with categories, users with roles

When Not to Use Genstruct ¶

Genstruct may not be the best solution for:

1. Highly Dynamic Data: Data that changes frequently at runtime
2. Extremely Large Datasets: Datasets with thousands of entries (though this depends on usage patterns)
3. User-Generated Content: Content created and modified by end-users
4. Data Requiring External Editing: When non-developers need to frequently edit the data

Real-World Use Cases ¶

Content Management Systems ¶

Pre-generate content structures while allowing runtime content to reference these structures:

// Generated site sections
var SectionNews = Section{...}
var SectionBlog = Section{...}

// Runtime content referencing static structures
content.Section = SectionNews

E-commerce Product Catalogs ¶

Define product categories, attributes, and relationships statically:

// Access static product categories
for product in dynamicProducts {
    if product.CategorySlug == ProductCategorySportwear.Slug {
        // Process sporting goods
    }
}

API Specifications ¶

Generate API endpoints, parameters, and response types:

// Check if an endpoint requires authentication
if APIEndpointUserProfile.RequiresAuth {
    // Perform authentication
}

Internationalization and Localization ¶

Generate language packs and translations:

// Access translations
message := LocaleEnUs.Errors.NotFound

Conclusion ¶

Genstruct transforms the way you work with static data in Go by bringing it into the type system, improving performance, developer experience, and reliability. By generating Go code from your data, you get the best of both worlds: the flexibility of external data formats with the robustness and safety of the Go compiler.