Multiple sets of const names with scope in Go

I have a Go application that requires an unbounded number of sets of constants. The application also requires that I be able to map strings to (integer) consts, and vice versa at runtime. The names of the constants are guaranteed only to be valid identifiers, so it's a near certainty that there will be duplicate const names. In particular, each set of constants has an element called "Invalid". In C++11, I'd use enum classes to achieve scope. In Python, I'd probably use class variables. I'm struggling to find an idiomatic way to express this in Go. Options that I've looked at include:

• Using a separate package for every set of consts. This has lots of disadvantages, because I'd rather the whole set be in the same package so that I can build support for these sets at the package level, and so that I can test the whole lot without overly complicating the test code to do multi-package testing at once.

first.go:

package first
type First int
const (
    ConstOne First = iota
    ConstTwo
    Invalid = -1
)

func IntToCode(fi First)string { ... }
func CodeToInt(code string)First { ... }

second.go:

package second
type Second int
const (
    ConstOne Second = iota
    ConstTwo
    Invalid = -1
)

func IntToCode(se Second)string { ... }
func CodeToInt(code string)Second { ... }

example.go:

import (
    "first"
    "second"
)

First fi = first.CodeToInt("ConstOne")
Second se = second.Invalid

• Using the tried-and-true technique of a globally unique prefix for each const. Given, though, that the number of sets is really big, having to essentially invent and manage a bunch of namespaces using a coding convention is awkward at best. This option also forces me to modify the names of the consts (which is the whole point of using them).

first.go:

package mypackage

type First int

const (
    FI_CONSTONE First = iota
    FI_CONSTTWO
    FI_INVALID = -1
)

func IntToCode(fi First)string { ... }
func CodeToInt(code string)First { ... }

second.go:

package mypackage

type Second int

const (
    SE_CONSTONE Second = iota
    SE_CONSTTWO
    SE_INVALID = -1
)

func IntToCode(se Second)string { ... }
func CodeToInt(code string)Second { ... }

example.go:

package mypackage

import (
    "first"
    "second"
)

First fi = first.CodeToInt("ConstOne")
Second se = SE_INVALID

What's a better, more idiomatic solution? I'd love to be able to say things like:

First fi = First.Invalid

but I haven't been successful in coming up with an approach that allows this.

You could have separate packages for your separate code sets and a single package for defining the higher level functionality associated with codes and write tests for that higher level package.

I haven't compiled or tested any of this:

E.g. for a code set:

package product // or whatever namespace is associated with the codeset

type Const int

const (
    ONE Const = iota
    TWO
    ...
    INVALID = -1
)

func (c Const) Code() string {
    return intToCode(int(c)) // internal implementation
}

type Code string

const (
     STR_ONE Code = "ONE"
     ...
)

func (c Code) Const() int {
    return codeToInt(string(c)) // internal implementation
}

E.g. for the higher level functions package:

// codes.go
package codes

type Coder interface{
    Code() string
}

type Conster interface{
    Const() int
}

func DoSomething(c Coder) string {
    return "The code is: " + c.Code()
}    

// codes_product_test.go
package codes

import "product"

func TestProductCodes(t *testing.T) {
    got := DoSomething(product.ONE) // you can pass a product.Const as a Coder
    want := "The code is: ONE"
    if got != want {
        t.Error("got:", got, "want:", want)
    }
}

Edit:

To retrieve the const for a particular code you could do something like

product.Code("STRCODE").Const()

Maybe it's better if Const() returns a Coder so that product.Code("ONE").Const() can be a product.Const. I think if you play around with it there are a few options and there will be a good one in there somewhere.