Value Conversion, Assignment And Comparison Rules In Go

• values of type byte and uint8 can be converted to each other.
• values of type rune and int32 can be converted to each other.
• values of type []byte and []uint8 can be converted to each other.

package main

func main() {
	// []int, IntSlice and MySlice share
	// the same underlying type: []int
	type IntSlice []int
	type MySlice  []int

	var s  = []int{}
	var is = IntSlice{}
	var ms = MySlice{}
	var x struct{n int `foo`}
	var y struct{n int `bar`}

	// The two lines both fail to compile.
	/*
	is = ms
	ms = is
	*/

	// Must use explicit conversions here.
	is = IntSlice(ms)
	ms = MySlice(is)
	x = struct{n int `foo`}(y)
	y = struct{n int `bar`}(x)

	// Implicit conversions are okay here.
	s = is
	is = s
	s = ms
	ms = s
}

package main

func main() {
	type MyInt int
	type IntPtr *int
	type MyIntPtr *MyInt

	var pi = new(int) // type is *int
	var ip IntPtr = pi // ok, same underlying type

	// var _ *MyInt = pi // can't convert implicitly
	var _ = (*MyInt)(pi) // ok, must explicitly

	// var _ MyIntPtr = pi  // can't convert implicitly
	// var _ = MyIntPtr(pi) // can't convert explicitly
	var _ MyIntPtr = (*MyInt)(pi)  // ok
	var _ = MyIntPtr((*MyInt)(pi)) // ok

	// var _ MyIntPtr = ip  // can't convert implicitly
	// var _ = MyIntPtr(ip) // can't convert explicitly
	var _ MyIntPtr = (*MyInt)((*int)(ip))  // ok
	var _ = MyIntPtr((*MyInt)((*int)(ip))) // ok
}

package main

func main() {
	type C chan string
	type C1 chan<- string
	type C2 <-chan string

	var ca C
	var cb chan string

	cb = ca // ok, same underlying type
	ca = cb // ok, same underlying type

	var _, _ chan<- string = ca, cb // ok
	var _, _ <-chan string = ca, cb // ok
	var _ C1 = cb // ok
	var _ C2 = cb // ok

	// var _ = C1(ca) // compile error
	// var _ = C2(ca) // compile error
	var _ = C1((chan<- string)(ca)) // ok
	var _ = C2((<-chan string)(ca)) // ok
}

package main

type Filter interface {
	Filte(n int) bool
}

type MultipleFilter struct {
	Divisor int
}

func (mf MultipleFilter) Filte(n int) bool {
	return n % mf.Divisor == 0
}

func main() {
	var mf = MultipleFilter{11}
	// mf's type MultipleFilter implements Filter,
	// so here implicit conversion is okay.
	var filter = mf

	// all types implement interface{} type, so any
	// value can be converted to interface{} implicitly.

	var n int = 123
	var b bool = true
	var s string = "abc"

	var _ interface{} = n
	var _ interface{} = b
	var _ interface{} = s
	var _ interface{} = mf

	// interface type Filter also implements interface{}
	var _ interface{} = filter
}

Many parameters of the functions in standard packages are of type interface{}. As all types implement interface{}, so any value can be passed for such parameters without explict conversion.

package main

func main() {
	var _ []int = nil
	var _ map[string]int = nil
	var _ chan string = nil
	var _ func()() = nil
	var _ *bool = nil
	var _ interface{} = nil

	var _ int = 123.0
	var _ float64 = 123
	var _ int32 = 1.23e2
	var _ int8 = 1 + 0i
}

package main

func main() {
	const I = 123
	const I1, I2 int8 = 0x7F, -0x80
	const I3, I4 int8 = I, 0.0

	const F = 0.123456789
	const F32 float32 = F
	const F32b float32 = I
	const F64 float64 = F
	const F64b = float64(I3)

	const C1, C2 complex64 = F, I
	const I5 = int(C2)
}

• Complex non-constant values can't be converted to floating-point and integer types.
• Floating-point and integer non-constant values can't be converted to complex types.
• Data overflow and rounding are allowed in non-constant number conversions. When converting a floating-point non-constant number to an integer, the fraction is discarded (truncation towards zero).

Go specification states:

So, the comparison rule is much like the assignment rule. In other words, two values are comparable if one can be implicitly converted to the type of the other.

• untyped boolean values can be compared with untyped boolean values;
• untyped numeric values can be compared with untyped numeric values;
• untyped string values can be compared with untyped string values,

The results of comparing two untyped constant values obey intuition.

Any comparison results an untyped boolean value.

Note, currently (Go 1.11), if one of the two operands in a comparison is an interface value, and the other operand is a non-interface value of an uncomparable type which implements the former operand interface type, both the standard Go compiler (gc) and gccgo fail to compile the comparison. This might be a bug of gc and gccgo, or not. When this issue is clarfied and it is proved it is not a bug, the above comparison rule descriptions will get adjusted accordingly.

• map, slice and function types don't support comparison. (But values of these types can be compared to the bare nil identifier).
• any struct type with a field whose type is uncomparable and any array type which element type is uncomparable also doesn't support comparison.
• bare nil identifiers (untyped nil values) can't be compared with each other.

[]int
map[string]bool
func() int
struct{x map[int]int} // one field element type is uncomparable
[5][]int              // array element type is uncomparable

package main

// The types of the following variables are all uncomparable.
var s []int
var m map[int]int
var f func()()
var t struct {
	s []int
	n int
}
var a [5]map[int]int

func main() {
	// The following lines fail to compile.
	/*
	_ = s == s
	_ = m == m
	_ = f == f
	_ = t == t
	_ = a == a
	_ = nil == nil
	*/

	// The following lines compile okay.
	_ = s == nil
	_ = m == nil
	_ = f == nil
}

1. If T is a struct type, then each pair of the corresponding fields of the two struct values will be compared.
2. If T is an array type,then each pair of the corresponding elements of the two array values will be compared.
3. If T is an interface type, please read how two interface values are compared.
4. If T is a string type, please read how two string values are compared.
5. If T is a boolean, numeric or pointer (either safe or unsafe), then each pair of the corresponding bytes occupied in memory by the two values will be compared. The two values are equal only if all the byte comparisons result true.
6. If T is a channel type, the two channel values are equal if they both reference the same underlying channel structure.

Please note, comparing two interfaces with the same uncomparable dynamic type produces a panic. A sub-comparison of the first three cases mentioned above may also be an interface value comparison. So comparisons of the first three cases may be also possible to produce panics.

Here is an example in which some panics will occur in comparisons.

package main

func main() {
	type T struct {
		a interface{}
		b int
	}
	var x interface{} = []int{}
	var y = T{a: x}
	var z = [3]T{}

	// Each of the following line can produce a panic.
	_ = x == x
	_ = y == y
	_ = z == z
}

Please note, the two code lines involved z compile okay for the go build and go install commands in any version of Go SDK, but fail to compile for the go run command in Go SDK 1.9 and 1.10. This is a known bug of the standard Go compiler 1.9 and 1.10.