Go语言中构建类型安全、私有且有序的常量列表

package mymodule // 假设在 mymodule 包中

// opCode 定义了一个新的整数类型，用于表示操作码
type opCode int

// 定义 FUSE 操作码常量列表
const (
    // lookupOp 被初始化为 iota + 1，即 1。
    // 后续未显式赋值的常量会沿用 lookupOp 的表达式，并递增 iota。
    lookupOp opCode = iota + 1 // 1
    forgetOp                    // 2
    getattrOp                   // 3
    setattrOp                   // 4
    readlinkOp                  // 5
    symlinkOp                   // 6
    _                           // iota 为 7，但该值被跳过，不声明常量
    mknodOp                     // 8 (iota 此时为 8)
    // et cetera ad nauseam
)

func ExampleUsage() {
    // 类型安全：可以比较同类型的常量
    if lookupOp == forgetOp {
        // 这将永远不会发生
    }

    // 编译错误：不能将 opCode 类型直接赋值给 int 类型变量，反之亦然
    // var x int = lookupOp // 编译错误: cannot use lookupOp (type opCode) as type int in assignment
    // var y opCode = 100   // 编译错误: cannot use 100 (type int) as type opCode in assignment

    // 但可以直接与字面量整数进行比较（这是 Go 语言的特性，无法完全阻止）
    if lookupOp == 1 {
        // 这是允许的，因为 Go 语言允许自定义类型与底层类型的值进行比较。
        // 这也是需要注意的地方，虽然类型安全，但底层是整数的本质未变。
    }
}

package mymodule

// opCode 是私有的底层整数类型
type opCode int

const (
    internalLookupOp opCode = iota + 1
    internalForgetOp
    // ... 其他内部常量
)

// OpCode 是对外暴露的公共类型，封装了内部的 opCode
type OpCode struct {
    code opCode
}

// NewOpCode 是一个工厂函数，用于创建 OpCode 实例
func NewOpCode(val opCode) OpCode {
    // 可以在这里进行值校验
    return OpCode{code: val}
}

// LookupOp 是对外暴露的 OpCode 实例
var LookupOp = NewOpCode(internalLookupOp)
var ForgetOp = NewOpCode(internalForgetOp)
// ... 其他公共 OpCode 实例

// Equal 方法用于比较两个 OpCode 实例是否相等
func (o OpCode) Equal(other OpCode) bool {
    return o.code == other.code
}

func ExternalUsage() {
    // 外部包只能通过公共变量访问常量
    if LookupOp.Equal(ForgetOp) {
        // 不会发生
    }

    // 编译错误：无法直接访问私有字段或进行底层类型比较
    // if LookupOp.code == 1 { ... } // 编译错误: LookupOp.code is not exported
    // if LookupOp == 1 { ... }       // 编译错误: cannot convert 1 (type int) to type OpCode
}