Explanation of checking if value implements interface

I've read "Effective Go" and other Q&As like this: golang interface compliance compile type check , but nonetheless I can't understand properly how to use this technique.

Please, see example:

type Somether interface {
    Method() bool
}

type MyType string

func (mt MyType) Method2() bool {
    return true
}

func main() {
    val := MyType("hello")

    //here I want to get bool if my value implements Somether
    _, ok := val.(Somether)
    //but val must be interface, hm..what if I want explicit type?

    //yes, here is another method:
    var _ Iface = (*MyType)(nil)
    //but it throws compile error
    //it would be great if someone explain the notation above, looks weird
}

Is there any simple ways (eg without using reflection) check value if it implements an interface?

You only have to check if a value implements an interface if you don't know the value's type. If the type is known, that check is automatically done by the compiler.

If you really want to check anyways, you can do it with the second method you gave:

var _ Somether = (*MyType)(nil)

which would error at compile time:

prog.go:23: cannot use (*MyType)(nil) (type *MyType) as type Somether in assignment:
    *MyType does not implement Somether (missing Method method)
 [process exited with non-zero status]

What you are doing here, is assigning a pointer of MyType type (and nil value) to a variable of type Somether, but since the variable name is _ it is disregarded.

If MyType implemented Somether, it would compile and do nothing

Following will work:

val:=MyType("hello")
var i interface{}=val
v, ok:=i.(Somether)

Explanation of checking if value implements interface

Related

Recent Posts