Simple Code Generator in Go

This challenge focuses on building a basic code generator in Go. Code generation is a powerful technique used to automate the creation of repetitive code, reducing development time and potential errors. You'll be creating a generator that produces Go code based on a simple data structure definition.

Problem Description

You are tasked with creating a Go program that generates Go code for structs and their associated methods based on a provided input. The input will be a slice of strings, where each string represents a field in the struct. The generator should produce a complete Go struct definition, including the type declaration, field definitions, and a basic String() method for printing the struct's contents.

What needs to be achieved:

• Parse a slice of strings representing struct field names.
• Generate a Go struct definition with the provided field names.
• Generate a String() method for the struct that returns a string representation of the struct's fields.

Key Requirements:

• The generated code must be valid Go code.
• The generated struct name should be "GeneratedStruct".
• Each field should be of type string.
• The String() method should concatenate the field names and their values with commas.

Expected Behavior:

The program should take a slice of strings as input and print the generated Go code to the console. The generated code should be well-formatted and readable.

Edge Cases to Consider:

• Empty input slice: Should generate a struct with no fields and an empty String() method.
• Input slice with a single field: Should generate a struct with one field and a String() method.
• Input slice with many fields: Should generate a struct with many fields and a String() method.

Examples

Example 1:

Input: ["Name", "Age", "City"]
Output:
```go
type GeneratedStruct struct {
	Name string
	Age  string
	City string
}

func (s GeneratedStruct) String() string {
	return "Name: " + s.Name + ", Age: " + s.Age + ", City: " + s.City
}

Explanation: The input slice contains three field names. The generator creates a struct named GeneratedStruct with three string fields: Name, Age, and City. It also generates a String() method that concatenates the field names and their values.

Example 2:

Input: ["ID"]
Output:
```go
type GeneratedStruct struct {
	ID string
}

func (s GeneratedStruct) String() string {
	return "ID: " + s.ID
}

Explanation: The input slice contains one field name. The generator creates a struct named GeneratedStruct with one string field: ID. It also generates a String() method that concatenates the field name and its value.

Example 3:

Input: []
Output:
```go
type GeneratedStruct struct {
}

func (s GeneratedStruct) String() string {
	return ""
}

Explanation: The input slice is empty. The generator creates an empty struct named GeneratedStruct and an empty String() method.

Constraints

• The input slice will contain only strings.
• The length of the input slice can be between 0 and 100 (inclusive).
• The generated code should be reasonably formatted (e.g., using proper indentation).
• The generated code should not include any unnecessary comments or whitespace.

Notes

• Consider using string concatenation to build the generated code.
• Pay attention to Go syntax and formatting rules.
• You can use fmt.Println to print the generated code to the console.
• This is a simplified code generation exercise. Real-world code generators are often more complex and use templates.
• Focus on generating the correct Go code structure, not on advanced formatting or error handling. The goal is to demonstrate the basic principle of code generation.