type Track int
type TrackType  []Track
func main() {
    tracks := []Track{
        1,2,
    }
    var tracksType TrackType = tracks
    var tracks2 []Track = tracksType
    fmt.Println(tracksType,tracks2)
}

TrackType是一个新的类型，为什么可以和[]Track相互转换！！
还有一个问题是，既然type定义的是新类型，那么type HandleFunc func()为什么指名传递HandleFunc,但是传递一个匿名函数也可用。后来才想明白，func()本来就不是一个类型(准备的说是一个没有命名的类型，如int这种是有名字的类型所以是命名类型)，而使用type给func()定义了一个类型(有了名字)，所以能够进行互换，但是如果再给HandleFunc定一个新类型就不能互换了，如type HandleFunc2 HandleFunc，HandleFunc2和HandleFunc不能互换，因为两者都是命名类型，那么此时两者类型就不一样了。

如func(),数组类型[]int,struct,接口,slice,map,channel指针这些都不是命名类型。

参考下go1.9 新特性 https://github.com/golang/proposal/blob/master/design/18130-type-alias.md：

type Name1 map[string]string
type Name2 map[string]string
type Alias = map[string]string

According to Go assignability, a value of type Name1 is assignable to map[string]string (because the latter is not a named type) but a value of type Name1 is not assignable to Name2 (because both are named types, and the names differ). In this example, because Alias is an alternate spelling for map[string]string, a value of type Name1 is assignable to Alias (because Alias is the same as map[string]string, which is not a named type).

翻译就是

根据Go可分配性，Name1类型的值可以分配给map [string]字符串（因为后者不是命名类型），但是Name1类型的值不能分配给Name2（因为它们都是命名类型，名称不同）。在此示例中，由于Alias是map [string]字符串的替代拼写，Name1类型的值可分配给Alias（因为Alias与map [string]字符串相同，而不是命名类型）。

从以上说明可以得出，对于slice,map[string]int,等类型，因为他们不是命名类型，所以在type MyType []Type的情况下，是可以将[]Type分配给MyType的，并且MyType也可以分配给[]Type。

Go的可分配性

对于赋值而言，以下情况可以将x的值赋给T类型。

• x的类型与T相同
• x的类型和T具有相同的底层类型，并且至少有一个不是定义类型(即有一个是非命名类型)
• T是一个接口，并且x实现了T
• x是一个双向通道，T是一个通道类型，并且x的类型和T具有相同的底层类型，至少有一个不是定义类型。
• x是nil的时候，可以赋给指针类型，函数类型，slice,map,channel等引用类型和接口类型等
• x是由类型T的值表示的无类型常量。

针对以上的第二条做个解释，如下代码示例：

type Func func()
type Func2 Func
func Test1(f Func){
}

func Test2(f Func2){
}
func main(){
    m := func(){

    }
    Test1(m)
    Test2(m)
}

上述代码是可以运行的，其中m的类型是func()非命名类型，但是传递Test1和Test2中都可以使用，说明在传递的时候func()和Func以及Func2都能互相转换，其中func()和Func能进行互相赋值好理解，但是为什么func()和Func2也能互相赋值，这个时候看下第二条规则就明白了:x的类型和T具有相同的地底层类型，并且至少有一个不是定义类型(即有一个是非命名类型),因为func()和Func2有相同的底层类型，其中func()不是定义类型，所以两者可以互相赋值。
但是以下代码无法正确执行，因为m类型是指定的Func，不符合以上任何一条规则，所以不能和Func2进行互相转换。

func main(){
      var m Func = func(){}
      Test1(m)  //success，因为Func是非命名类型的第一个命名，可互相转换
      Test2(m) // failed，Func和Func2不是同一个类型
}