How to implement case-insensitive flag parsing in Go?

To implement case-insensitive flag parsing in Go, you can create a custom FlagSet that changes the default behavior of flag parsing. Here is an example implementation:

package main

import (
	"flag"
	"strings"
)

// CustomFlagSet is a custom FlagSet that handles case-insensitive flag parsing.
type CustomFlagSet struct {
	*flag.FlagSet
}

// NewCustomFlagSet creates a new CustomFlagSet.
func NewCustomFlagSet(name string, errorHandling flag.ErrorHandling) *CustomFlagSet {
	fs := flag.NewFlagSet(name, errorHandling)
	return &CustomFlagSet{fs}
}

// Lookup overrides the default Lookup function to perform case-insensitive flag lookup.
func (cfs *CustomFlagSet) Lookup(name string) *flag.Flag {
	normalizedName := strings.ToLower(name)
	flag := cfs.FlagSet.Lookup(normalizedName)
	if flag == nil {
		flag = cfs.FlagSet.Lookup(name) // perform case-sensitive lookup if case-insensitive lookup fails
	}
	return flag
}

Then, you can use this custom flag set to parse command-line arguments:

package main

import (
	"fmt"
)

func main() {
	cfs := NewCustomFlagSet("example", flag.ContinueOnError)
	flag.StringVar(cfs.FlagSet, "input", "", "input file")
	flag.Parse()

	// Access the flag value using the custom flag set
	inputFile := cfs.FlagSet.Lookup("input").Value.String()
	fmt.Println("Input file:", inputFile)
}

With this setup, you can run the program with command-line arguments in any case:

$ go run main.go -INPUT=input.txt
Input file: input.txt

Note that in this example, the custom flag set only handles the case-insensitive flag lookup. The actual parsing of flag values and error handling is still handled by the default flag package implementation.