Extending constants in Golang

Here's my requirement: I have 2 sets of constants. I want to form a third set which is nothing but a union of the above 2 sets. How do I achieve that?

type CompOp byte

const (
    EQUAL CompOp = iota
    NOT_EQUAL
)

type LogOp byte

const (
    AND LogOp = iota
    OR
)

I want a third set, say Operator

type Op {CompOp, LogOp}

or

var Op = CompOp + LogOp

But neither of the above 2 ways work. How do I achieve this requirement?

The above is important to me I'm trying to achieve this :

type logExpr struct { 
    expr Expression
    op LogOp 
}  

type compExpr struct { 
    expr Expression
    op CompOp 
} 

type filterExpr struct { 
    expr Expression
    op Op 
}

CompOp and LogOp are not sets of the same type. They cannot be combined this way. If they could, they would conflict anyway, since both EQUAL and AND are both 0 (since they're the first iota in their blocks). You will need another design.

The most common design would be to combine all the operators into a single const block, and then provide functions like IsCompare() or IsLogic() to distinguish them if that's necessary. See os.IsExist() and os.IsPermission() as a template.

Here's one way that I might implement it. It wastes a few values for min/max, but it keeps the code very simple to read and easy to update.

Playground

const (
	// Comparison operators
	minComparison Op = iota
	EQUAL
	NOT_EQUAL
	maxComparison

	// Logic operators
	minLogic
	AND
	OR
	maxLogic
)

func IsComparsion(op Op) bool {
	return op >= minComparison && op <= maxComparison
}

func IsLogic(op Op) bool {
	return op >= minLogic && op <= maxLogic
}

But can you treat the different kinds of ops as types? Yeah, you can, and maybe it'll work better for you. For example, consider (playground):

type Op interface {
	isOp()
}

type CompOp byte

const (
	EQUAL CompOp = iota
	NOT_EQUAL
)

func (op CompOp) isOp() {}

type LogOp byte

const (
	AND LogOp = iota
	OR
)

func (op LogOp) isOp() {}

func doOpThingBasedOnValue(op Op) {
	switch op {
	case EQUAL:
		println("passed equal")
	case AND:
		println("passed and")
	}
}

func doOpThingBasedOnType(op Op) {
	switch op.(type) {
	case CompOp:
		println("passed a comp")
	case LogOp:
		println("passed a logic")
	}
}

So maybe that's even closer to what you're thinking of. Note that even though both AND and EQUAL are "0", as an interface, they are distinguishable, so we can switch on them like you'd want. Go is cool that way.