Is a Go interface value an entire variable that implements the interface?

Question

New to Go here. I was taking a tour of Go and came across one word that I was confused what it was.

It's the 11th page of the Method section here. It says, "interface values can be thought of as a tuple of a value and a concrete type."

My understanding is that an interface value is a variable that implements that interface. E.g.:

type Animal interface {
    run()
}

type Cat struct { … }

func main() {
    kitty := Cat{ … }
}

func (c Cat) run() { … }

Is kitty an interface value?

No kitty is not an interface value. `kitty` is a value of type `Cat`. Although type `Cat` implements the `Animal` interface, `kitty`'s type is the concrete type `Cat`. — mkopriva, Jun 01 '18 at 09:06
Since you uttered that you're new to Go. Maybe you can have a look at the concept _composition over inheritence_ which interfaces of Go is based on. — vahdet, Jun 01 '18 at 09:25
Composition over inheritance has nothing to do with interfaces. While you can compose interfaces, that is a feature of interfaces, not the basis of interfaces. — Adrian, Jun 01 '18 at 14:46

icza · Accepted Answer · 2018-06-01T10:04:31.507

In your case since you used short variable declaration to create kitty, the type is inferred from the right-hand side expression, and type of kitty will be the concrete type Cat.

But since the Cat concrete type (non-interface type) implements the Animal interface type, you may assign a value of Cat to a variable whose type is Animal, like in this example:

kitty := Cat{}
var kitty2 Animal = kitty

"Implements" by spec means:

An interface type specifies a method set called its interface. A variable of interface type can store a value of any type with a method set that is any superset of the interface. Such a type is said to implement the interface.

Interface values, schemantically, contain a (value; type) pair, being the value stored in them, and their concrete type.

For more details about interface internals, read blog post: The Go Blog: The Laws of Reflection
And Go Data Structures: Interfaces (by Russ Cox).

For an introduction why interfaces are needed or how / when to use them, see Why are interfaces needed in Golang?

score 1 · Answer 2 · answered Jun 01 '18 at 11:23

"interface values can be thought of as a tuple of a value and a concrete type." -> The interface in a way just cares if your type implements the methods it needs. It's data structure stores two things : 1. The type which implements it 2. A value (of the type in #1)

Here's a simple example just to give you an idea what it is like:

package main

import (
    "fmt"
    "reflect"
)

type Animal interface {
    run()
}

type Cat struct {
    a int
}

func main() {
    kitty := Cat{2}
    var anim Animal
    fmt.Println(kitty)
    kitty.run()
    anim = kitty //interface
    fmt.Println(anim)
    anim.run()
    t := reflect.TypeOf(anim)
    v := reflect.ValueOf(anim)
    fmt.Println(t.String())
    fmt.Println(v)

}

func (c Cat) run() {
    fmt.Println("Have fun")
}

Output :

{2}
Have fun
{2}
Have fun
main.Cat
{2}

https://play.golang.org/p/xeozR3VT-9J though you'd need to read up more and try a few examples on your own to understand this better.

Is a Go interface value an entire variable that implements the interface?

2 Answers2