如果我有一个定义为字符串常量的类型，为什么不能将该类型传递给实际的字符串呢？

Question

Here's what I mean: Go playground

The "StringType" type is a string and nothing more. The compiler complains about line 21, but for some reason, line 16 works without issue (if you comment 21 and uncomment 22).

What is the difference between those two lines (as both as passing StringType to the same function), and why does one work and the other not?

Here's the code, in-line:

package main

import (
    "fmt"
    "strings"
)

type StringType string

const (
    FirstString  = "first"
    SecondString = "second"
)

func main() {
    fmt.Println(strings.Contains(FirstString, SecondString))    // line 16
}

func myFunc(a StringType, b StringType) bool {

    return strings.Contains(a, b)                               // line 21
    //return false
}

Answer 1

Go has a strict typing system. StringType and string is not the same type, and you need to do a type conversion.

The Go specs states that:

A non-constant value x can be converted to type T in any of these cases:

x is assignable to T.
x's type and T have identical underlying types.
...
x is an untyped constant representable by a value of type T

Since StringType has the underlying type of string, this conversion is possible:

func myFunc(a StringType, b StringType) bool {

    return strings.Contains(string(a), string(b))
    //return false
}

Also, because FirstString and SecondString are untyped constants representable by StringType, this will allow you to pass it as a StringType, as stated by the specs.