How to Fix Go Interface Not Implemented

# How to Fix Go Interface Not Implemented

Interface not implemented errors occur when a type's methods don't match the interface requirements. Go requires exact method signature matching.

Error Patterns

Implicit Error (At Usage)

```text cannot use myType (type MyType) as type Interface in assignment: MyType does not implement Interface (missing Method method)

cannot use &myType (type *MyType) as type Interface in assignment: *MyType does not implement Interface (WrongMethod method has wrong signature) ```

Compile-Time Check Failure

var _ Interface = (*MyType)(nil)  // Triggers error if not implemented

Common Causes

1. 1.Method name mismatch - Wrong capitalization or spelling
2. 2.Signature mismatch - Different parameters or return types
3. 3.Pointer vs value receiver - Method on pointer but using value
4. 4.Missing method - Type doesn't have required method
5. 5.Exported vs unexported - Interface method exported, type method unexported

Problematic Examples

Method Name Mismatch

```go type Reader interface { Read(p []byte) (n int, err error) }

type MyReader struct{}

func (m *MyReader) read(p []byte) (n int, err error) { // lowercase return 0, nil }

// Error: *MyReader does not implement Reader (missing Read method) ```

Signature Mismatch

```go type Writer interface { Write(p []byte) error // Single return }

type MyWriter struct{}

func (m *MyWriter) Write(p []byte) (int, error) { // Two returns return 0, nil }

// Error: wrong signature for Write method ```

Pointer vs Value Receiver

```go type Interface interface { Method() }

type MyType struct{}

func (m *MyType) Method() {} // Pointer receiver

var i Interface = MyType{} // Error: MyType doesn't implement var i Interface = &MyType{} // Works: pointer satisfies ```

Solutions

Solution 1: Fix Method Name (Export)

```go type Reader interface { Read(p []byte) (n int, err error) }

type MyReader struct{}

// CORRECT: Export method with capital letter func (m *MyReader) Read(p []byte) (n int, err error) { return 0, nil } ```

Solution 2: Fix Method Signature

```go type Writer interface { Write(p []byte) error }

type MyWriter struct{}

// CORRECT: Match signature exactly func (m *MyWriter) Write(p []byte) error { return nil } ```

Solution 3: Use Pointer When Needed

```go type Interface interface { Method() }

type MyType struct{}

func (m *MyType) Method() {} // Pointer receiver

// CORRECT: Use pointer var i Interface = &MyType{}

// Or implement on value too func (m MyType) Method() {} // Value receiver (copies) var i Interface = MyType{} // Now works ```

Solution 4: Implement All Interface Methods

```go type ReadWrite interface { Read(p []byte) (n int, err error) Write(p []byte) (n int, err error) }

type MyRW struct{}

// Implement BOTH methods func (m *MyRW) Read(p []byte) (n int, err error) { return 0, nil }

func (m *MyRW) Write(p []byte) (n int, err error) { return 0, nil } ```

Solution 5: Add Compile-Time Check

```go // Add this at package level for early detection var _ Interface = (*MyType)(nil) // Check pointer var _ Interface = (MyType)(nil) // Check value (if needed)

// This fails at compile time if not implemented ```

Solution 6: Use Interface Composition

```go type Reader interface { Read(p []byte) (n int, err error) }

type Writer interface { Write(p []byte) (n int, err error) }

// Compose interfaces type ReadWriter interface { Reader Writer }

type MyRW struct{}

func (m *MyRW) Read(p []byte) (n int, err error) { return 0, nil } func (m *MyRW) Write(p []byte) (n int, err error) { return 0, nil }

// Now MyRW implements ReadWriter ```

Solution 7: Embed Existing Implementation

```go type Reader interface { Read(p []byte) (n int, err error) }

type BaseReader struct{}

func (b *BaseReader) Read(p []byte) (n int, err error) { return 0, nil }

// Embed to inherit implementation type MyReader struct { BaseReader // Embeds Read method }

// Can override if needed func (m *MyReader) Read(p []byte) (n int, err error) { // Custom implementation return m.BaseReader.Read(p) // Or call embedded } ```

Solution 8: Fix Pointer/Value Receiver Correctly

```go type Modifier interface { Modify() // Needs to modify state }

type MyType struct { value int }

// CORRECT: Use pointer for methods that modify func (m *MyType) Modify() { m.value++ // Modifies the instance }

// Use pointer to satisfy interface var m Modifier = &MyType{value: 0} m.Modify()

// For read-only methods, value receiver is fine type Getter interface { Get() int }

func (m MyType) Get() int { // Value receiver return m.value }

var g Getter = MyType{value: 5} // Works ```

Debugging Interface Issues

Check Implementation

```go // Use reflection to check interface satisfaction import "reflect"

func checkImplementation(t reflect.Type, iface reflect.Type) bool { if iface.Kind() != reflect.Interface { return false }

for i := 0; i < iface.NumMethod(); i++ { method := iface.Method(i) m, ok := t.MethodByName(method.Name) if !ok { return false // Method missing } if m.Type != method.Type { return false // Signature mismatch } } return true } ```

List Interface Methods

```go type MyInterface interface { Method1() Method2() int }

func listMethods(i MyInterface) { t := reflect.TypeOf(i) for i := 0; i < t.NumMethod(); i++ { m := t.Method(i) fmt.Println(m.Name, m.Type) } } ```

Best Practices

Always Add Compile-Time Check

// At top of file implementing interface
var _ SomeInterface = (*MyImplementation)(nil)

Choose Receiver Type Correctly

Use Descriptive Interface Names

```go // Good: Verb-based for single method type Reader interface { Read(...) } type Writer interface { Write(...) }

// Good: Noun-based for multiple methods type ReadWriter interface { Read(...); Write(...) }

// Avoid: Generic names type Doer interface { Do(...) } // Too vague ```

Prevention Tips

1. 1.Add compile-time interface check immediately after defining type
2. 2.Match exact signatures including parameter and return types
3. 3.Export method names with capital first letter
4. 4.Be consistent with receivers - use pointer for modifiers
5. 5.Use go vet: go vet ./... catches some interface issues

Related Errors

• method redeclared - Same method name with different receiver
• invalid receiver type - Receiver must be struct or pointer
• cannot refer to unexported field - Accessing private fields