Какова причина того, как Go делает «утверждение типа»?

Я пытаюсь осознать тот факт, что утверждение типа Golang работает только для переменных, которые явно определены как тип интерфейса, и не работает для конкретных типов (например, «string», «int32» и т. д. .).

Вот быстрый и простой пример кода, который иллюстрирует основную причину моего замешательства:

package main

import "fmt"

// here we define an interface type:
type Shape interface {
    DoubleSize() int32
}

// here we define a new type which is really just an int32:
type Rect int32

// here we make "Rect" type above comply with the "Shape" interface by implementing the methods of that interface
// and so, since the interfaces in Go are implemented implicitly, this should make the "Rect" type an implicit instance of the "Shape" interface
func (theShape Rect) DoubleSize() int32 {
    return int32(theShape) * 2
}

// this function expects its "someShape" parameter to be of "Shape" type (or "the type that quacks like "Shape" interface does))
func whateverFunction(someShape Shape) int32 {
    return someShape.DoubleSize()
}

func main() {
    var newRect = Rect(5)
    // ^^ if this is instead written as "var newRect Shape = Rect(5)" no error with type assertion happens down the line

    whateverFunction(newRect) // the function works just fine because "newRect" implicitly implements the "Shape" interface — the one that this function expects to receive.  

    // !! but type assertion doesn't work on "newRect"
    v, ok := newRect.(Shape) // error: invalid operation: newRect (variable of type Rect) is not an interface
    if !ok {
        fmt.Println("type assertion failed")
        return
    }
    fmt.Println("This is v:", v)
}

Как следует из названия этого вопроса, я не могу понять причину реализации утверждения типа для работы только с типами интерфейса и проверить, является ли базовое значение, присвоенное переменной, которая ЯВНО реализует этот интерфейс, тем, что мы указываем внутри ".( Т)" метод утверждения. Это заставляет меня чувствовать, что «утверждение типа» является непреднамеренным неправильным употреблением, которое подразумевает, что оно работает для всех типов, но не работает только для типов интерфейса.

Я имею в виду, что, очевидно, должна быть причина, стоящая за этим решением по дизайну языка, и я думаю, что это может иметь какое-то отношение к тому, как должен быть написан идиоматический Golang, но, хотя я видел много ресурсов по этому вопросу, они никогда не уточняют эта причина.

Причина, которая имеет для меня некоторый смысл, заключается в том, что программа Go должна «предпочтительно (я предполагаю, поскольку явное определение интерфейса не является обязательным)» быть написана со всеми переменными, представляющими некоторый интерфейс (поведение), и, следовательно, определяя явный интерфейс на переменная имеет смысл для ясности и удобочитаемости.

Но, как я уже упоминал, я никогда не видел, чтобы какие-либо ресурсы указывали, почему именно так реализована функциональность «утверждения типа» в Go, и я надеюсь, что вы поможете мне прояснить эту путаницу.

-- upd 1 - Добавление немного, чтобы прояснить мой вопрос:

По сути, я думаю, мой вопрос касается причины (которую я не понимаю) утверждение типа работает только тогда, когда интерфейс переменной реализован явно, но не когда интерфейс реализован неявно.

Как показано в «whateverFunction», код рассматривает «newRect» для реализации интерфейса «Shape» или «будет реализацией интерфейса «Shape»» (иначе функция не работала бы с этой переменной, но она работает). ), но код метода утверждения типа ".(T)" не считает "newRect" реализацией интерфейса "Shape".

Поэтому, если в Golang есть различия в том, что считать реализацией интерфейса, я подумал, что должна быть причина такого дизайнерского решения (дифференцировать).

И именно поэтому я упомянул, что единственная причина, о которой я пока мог думать, это то, что это был способ заставить людей писать код Go определенным образом.