Interface embedded in golang struct

Recently in to see context A strange usage was found in the underlying source code :struct Embedded inside interface,struct It has not been fully realized interface All interfaces of , I really didn't notice this usage before , I've only seen interface nesting interface Of , Decided to write down .

Go straight to the source ：src\context\context.go

type Context interface {
	Deadline() (deadline time.Time, ok bool)
	Done() <-chan struct{}
	Err() error
	Value(key interface{}) interface{}
}

cancelCtx Definition and concrete implementation of structure  

type cancelCtx struct {
	Context
	mu       sync.Mutex            // protects following fields
	done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
	children map[canceler]struct{} // set to nil by the first cancel call
	err      error                 // set to non-nil by the first cancel call
}

func (c *cancelCtx) Value(key interface{}) interface{} {
	if key == &cancelCtxKey {
		return c
	}
	return c.Context.Value(key)
}

func (c *cancelCtx) Done() <-chan struct{} {
	d := c.done.Load()
	if d != nil {
		return d.(chan struct{})
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	d = c.done.Load()
	if d == nil {
		d = make(chan struct{})
		c.done.Store(d)
	}
	return d.(chan struct{})
}

func (c *cancelCtx) Err() error {
	c.mu.Lock()
	err := c.err
	c.mu.Unlock()
	return err
}

 timerCtx Definition and concrete implementation of structure  

type timerCtx struct {
	cancelCtx
	timer *time.Timer // Under cancelCtx.mu.
	deadline time.Time
}
func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
	return c.deadline, true
}

Context Interface with 4 A way , however cancelCtx only 3 A way ,Deadline() It doesn't work , and timerCtx only Deadline(), other 3 One has not been realized .

I haven't seen this kind of writing in my cognition , To implement an interface is to implement all the methods of this interface , For example, in the source code emptyCtx

type emptyCtx int

func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
	return
}

func (*emptyCtx) Done() <-chan struct{} {
	return nil
}

func (*emptyCtx) Err() error {
	return nil
}

func (*emptyCtx) Value(key interface{}) interface{} {
	return nil
}

func (e *emptyCtx) String() string {
	switch e {
	case background:
		return "context.Background"
	case todo:
		return "context.TODO"
	}
	return "unknown empty Context"
}

var (
	background = new(emptyCtx)
	todo       = new(emptyCtx)
)

At that time, I saw this usage , Directly confused , Or I have a weak foundation ....

The embedded interface As struct An anonymous member of , You can assume this struct This is the member interface An implementation of , Regardless of struct Has it been realized interface Defined function .

type Student interface {
	Run()
	Walk()
}
type Pupil struct {
	age int
	Student
}
func NewPupil(age int) *Pupil{
	return &Pupil{age: age}
}
//func (p *Pupil) Run() {
//
//}
//
//func (p *Pupil) Walk(){
//
//}
func main(){
	p := NewPupil(100)
	var s Student = p
	fmt.Printf("%#v\n",s)
}

struct Pupil It didn't come true interface Any function in , Just put Student As an anonymous member ,main The function can run normally without error , explain p It is indeed considered Student The concrete realization of .

Since there is no implementation function , How to call the interface ？ The answer is Without implementation, you can't call , Once called crash. Only functions that have been implemented can be called . Noted above Run() and Walk() Let go of which ,s You can call which ...