¿Por qué no puedo asignar una estructura * a una interfaz *?

Solo estoy trabajando en la gira Go , y estoy confundido acerca de los punteros y las interfaces. ¿Por qué no compila este código Go?

package main

type Interface interface {}

type Struct struct {}

func main() {
    var ps *Struct
    var pi *Interface
    pi = ps

    _, _ = pi, ps
}

es decir, si Structes un Interface, ¿por qué no *Structsería un *Interface?

El mensaje de error que recibo es:

prog.go:10: cannot use ps (type *Struct) as type *Interface in assignment:
        *Interface is pointer to interface, not interface

Cuando tiene una estructura que implementa una interfaz, un puntero a esa estructura implementa automáticamente esa interfaz también. Es por eso que nunca tiene *SomeInterfaceen el prototipo de funciones, ya que esto no agregaría nada SomeInterface, y no necesita ese tipo de declaración de variable (vea esta pregunta relacionada ).

Un valor de interfaz no es el valor de la estructura concreta (ya que tiene un tamaño variable, esto no sería posible), pero es una especie de puntero (para ser más precisos, un puntero a la estructura y un puntero al tipo ) Russ Cox lo describe exactamente aquí :

Los valores de la interfaz se representan como un par de dos palabras que proporciona un puntero a la información sobre el tipo almacenado en la interfaz y un puntero a los datos asociados.

Esta es la razón Interface, y no *Interfacees el tipo correcto para mantener un puntero a una implementación de estructura Interface.

Entonces simplemente debes usar

var pi Interface

Esto es quizás lo que quisiste decir:

package main

type Interface interface{}

type Struct struct{}

func main() {
        var ps *Struct
        var pi *Interface
        pi = new(Interface)
        *pi = ps

        _, _ = pi, ps
}

Compila bien. Ver también aquí .

Aquí hay una manera muy simple de asignar una estructura a una interfaz:

package main

type Interface interface{}

type Struct struct{}

func main() {
    ps := new(Struct)
    pi := Interface(ps)

    _, _ = pi, ps
}

https://play.golang.org/p/BRTaTA5AG0S

Estoy usando la siguiente forma de, interface{}aunque solo estoy consumiendo eventsI interface{}como argumentos, todavía puedo enviar un Struct Pointers como se puede ver a continuación.

func Wait(seconds float64) *WaitEvent {
    return WaitEventCreate(seconds)
}

main.go

var introScene = []interface{}{
        storyboard.Wait(5),
        storyboard.Wait(2),
    }

    var storyboardI = storyboard.Create(stack, introScene)
    stack.Push(&storyboardI)

Ahora dentro de storyboard.gola función Crear archivo

type Storyboard struct {
    Stack  *gui.StateStack
    Events []interface{} //always keep as last args
}

func Create(stack *gui.StateStack, eventsI interface{}) Storyboard {
    sb := Storyboard{
        Stack: stack,
    }

    if eventsI != nil {
        events := reflect.ValueOf(eventsI)
        if events.Len() > 0 {
            sb.Events = make([]interface{}, events.Len())
            for i := 0; i < events.Len(); i++ {
                sb.Events[i] = events.Index(i).Interface()
            }
        }
    }

    return sb
}

Como puede ver arriba, el Storyboard.go está consumiendo solo, Events []interface{}pero de hecho, Im send es un puntero Struct y funciona bien.

otro ejemplo más aquí