What is the compile-time interface check idiom and why is it important?

// Idiom: assign nil pointer of the type to an interface variable
// This costs nothing at runtime (no allocation) but fails to compile
// if the interface is not satisfied.

type MyStore struct{ /* ... */ }
func (m *MyStore) Get(key string) (string, error)    { /* ... */ return "", nil }
func (m *MyStore) Set(key, val string) error          { /* ... */ return nil }
func (m *MyStore) Delete(key string) error            { /* ... */ return nil }

type Cache interface {
    Get(key string) (string, error)
    Set(key, val string) error
    Delete(key string) error
}

// Compile-time check — placed right after the type definition
var _ Cache = (*MyStore)(nil)  // fails to compile if *MyStore doesn't satisfy Cache

// Alternatively, for value receivers:
var _ Cache = MyStore{}        // check value type

// This check is also useful in test files:
// var _ http.Handler = (*MyHandler)(nil)
// var _ sort.Interface = ByAge(nil)

// What error you get on failure:
// cannot use (*MyStore)(nil) (type *MyStore) as type Cache in assignment:
//         *MyStore does not implement Cache (missing Delete method)