usage of interface{} on a struct to check if it satisfies an interface in golang

Question

Given the following code:

package main

import (
    "fmt"
)

type work interface {
    filter() bool
}

type organ struct {
    name string
}

func (s *organ) filter () bool {
    return true;
}


func main() {
    kidney := &organ {
            name : "kidney",    
        }

    _, ok := interface{}(kidney).(work)
    fmt.Println(ok);
}

I did not fully get the following part:

_, ok := interface{}(kidney).(work)

It seems to me, it is converting struct to the interface{} type, which I understand, but why is it required to convert to an interface{} type to check if it satisfies another interface. More specifically, why the following code fails?

ok := kidney.(work)

with error

invalid type assertion: kidney.(work) (non-interface type *organ on left)

The error message is pretty clear. Type assertions are for interface types only. Also, this check can be done at compile time with var _ work = &organ{}. — Ainar-G
– Ainar-G, Commented Nov 3, 2016 at 15:32
If you just have a variable of type "organ" you already know the type, so there's no need to assert that it's a worker (just call filter and if it's not a worker the build will fail). Casting a concrete type to an interface and then checking it is code smell in Go; there may be uses for it, but it's probably best if you let the compiler sort it out for you instead. — user1087001
– user1087001, Commented Nov 3, 2016 at 15:42
Does this answer your question? Explanation of checking if value implements interface — user12817546
– user12817546, Commented Mar 7, 2020 at 2:27

weberc2 · Accepted Answer · 2016-11-03 15:42:49Z

7

TL;DR If you always know the concrete type (e.g., kidney), then you don't need a type assertion; just pass it into your work variable and carry on--the compiler will guarantee that kidney satisfies the work interface, otherwise your program won't compile.

The reason you must first convert the concrete type into an interface{} is because type assertions (i.e., dynamic type checks) only make sense between dynamic types (i.e., interfaces). It doesn't make sense to do a runtime type check on a thing the compiler can guarantee at compile time. Hopefully this makes sense?

edited Nov 3, 2016 at 15:42

answered Nov 3, 2016 at 15:37

weberc2

8,0415 gold badges47 silver badges64 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

usage of interface{} on a struct to check if it satisfies an interface in golang

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related