type (
	nodeList = []*Node  // nodeList and []*Node are identical types
	Polar    = polar    // Polar and polar denote identical types
)

type (
	Point struct{ x, y float64 }  // Point and struct{ x, y float64 } are different types
	polar Point                   // polar and Point denote different types
)

type TreeNode struct {
	left, right *TreeNode
	value *Comparable
}

type Block interface {
	BlockSize() int
	Encrypt(src, dst []byte)
	Decrypt(src, dst []byte)
}

// A Mutex is a data type with two methods, Lock and Unlock.
type Mutex struct         { /* Mutex fields */ }
func (m *Mutex) Lock()    { /* Lock implementation */ }
func (m *Mutex) Unlock()  { /* Unlock implementation */ }
// 类型Mutex有两方法：Lock，Unlock

// NewMutex has the same composition as Mutex but its method set is empty.
type NewMutex Mutex
// 新类型NewMutex的方法集是空的

// The method set of PtrMutex's underlying type *Mutex remains unchanged,
// but the method set of PtrMutex is empty.
type PtrMutex *Mutex
// 新类型PtrMutex的方法集也是空的，，这个指针看来不是复合类型啊，，

// The method set of *PrintableMutex contains the methods
// Lock and Unlock bound to its embedded field Mutex.
type PrintableMutex struct {
	Mutex
}
// 疑问：为何是*PrintableMutex？这个就是复合类型吗？到底什么是复合类型？有哪些？

// MyBlock is an interface type that has the same method set as Block.
type MyBlock Block
// 这里的Block是 指针类型的，前一个官文示例中定义了

type TimeZone int

const (
	EST TimeZone = -(5 + iota)
	CST
	MST
	PST
)

func (tz TimeZone) String() string {
	return fmt.Sprintf("GMT%+dh", tz)
}

package main 

import (
	"fmt"
)

type TimeZone int

const (
	EST TimeZone = -(5 + iota)
	CST
	MST
	PST 
)

func (tz TimeZone) String() string {
	return fmt.Sprintf("GMT%+dh", tz)
}

func main() {
	var x TimeZone = 1
	fmt.Println(x.String())
	x = 123
	fmt.Println(x.String())
	x = -999123
	fmt.Println(x.String())
	
	fmt.Println(EST, CST, MST, PST)
}

GMT+1h
GMT+123h
GMT-999123h
GMT-5h GMT-6h GMT-7h GMT-8h