Implement Card Marking in Go

This challenge involves creating a system to represent and manage playing cards, including their suits and ranks. This is a fundamental building block for many card games and data structures, requiring careful consideration of data representation and potential operations. You will implement a Card type and associated functions to create, validate, and represent these cards.

Problem Description

Your task is to implement a Card type in Go that accurately represents a standard playing card. A standard deck of cards consists of 52 cards, divided into four suits (Hearts, Diamonds, Clubs, Spades) and thirteen ranks (2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King, Ace).

You need to:

1. Define a Card struct: This struct should encapsulate the suit and rank of a card.
2. Define Suit and Rank types: Use appropriate Go types (e.g., string or custom enumerated types) to represent the possible suits and ranks. Ensure that only valid suits and ranks can be assigned.
3. Implement a constructor function: Create a function NewCard(suit string, rank string) (*Card, error) that takes a suit and rank as strings and returns a *Card pointer. This function should validate the input suit and rank. If either is invalid, it should return an error.
4. Implement a String() method: Add a String() method to the Card struct that returns a human-readable string representation of the card (e.g., "Ace of Spades", "10 of Hearts").
5. Handle invalid inputs: The NewCard function must gracefully handle cases where invalid suit or rank strings are provided.

Key Requirements:

• The Suit type should support: Hearts, Diamonds, Clubs, Spades.
• The Rank type should support: 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King, Ace.
• The NewCard function must return a non-nil *Card and nil error for valid inputs.
• The NewCard function must return nil for *Card and a descriptive error for invalid inputs.
• The String() method should produce consistent and readable output.

Edge Cases:

• Providing empty strings for suit or rank.
• Providing non-existent suits or ranks (e.g., "Stars", "Joker").
• Case sensitivity of input strings (decide on a convention, e.g., case-insensitive comparison).

Examples

Example 1:

Input: suit="Hearts", rank="Ace"
Output:
Card: &{Hearts Ace}
String Representation: Ace of Hearts
Error: <nil>

Example 2:

Input: suit="Spades", rank="10"
Output:
Card: &{Spades 10}
String Representation: 10 of Spades
Error: <nil>

Example 3:

Input: suit="Stars", rank="Queen"
Output:
Card: <nil>
String Representation:
Error: invalid suit: Stars

Example 4:

Input: suit="Diamonds", rank="11"
Output:
Card: <nil>
String Representation:
Error: invalid rank: 11

Constraints

• The Suit and Rank types should be limited to the standard 4 suits and 13 ranks respectively.
• Input strings for suit and rank should be handled robustly, ideally case-insensitively.
• The NewCard function should return an error immediately upon detecting an invalid suit or rank.

Notes

Consider using constants or a map for defining valid suits and ranks to make validation efficient and maintainable. The errors package in Go is your friend for creating descriptive error messages. Think about how you want to handle case sensitivity for input strings – converting inputs to a consistent case (e.g., lowercase) before validation is a common approach.