package main

import "fmt"

type Named interface {
	Name() string
}

type NamedTwo interface {
	Name() string
}

type Registry interface {
	Named() Named
}

// implementNamed implements Named, NamedTwo interface.
type implementNamed struct{ name string }

func (n *implementNamed) Name() string {
	return n.name
}

type oneRegistry struct{}

func (r *oneRegistry) Named() Named {
	return &implementNamed{"one"}
}

type twoRegistry struct{}

func (r *twoRegistry) Named() NamedTwo {
	return &implementNamed{"two"}
}

func main() {
	oneReg := oneRegistry{}
	twoReg := twoRegistry{}

	expectNamed(oneReg.Named())
	expectNamed(twoReg.Named())
	expectNamedTwo(oneReg.Named())
	expectNamedTwo(twoReg.Named())

	type thingWithNamed struct {
		named Named
	}

	// This works; even though twoReg.Named() returns a NamedTwo
	foo := thingWithNamed{}
	foo.named = oneReg.Named()
	fmt.Println(foo.named.Name())

	foo.named = twoReg.Named()
	fmt.Println(foo.named.Name())

	type thingWithRegistry struct {
		registry Registry
	}

	bar := thingWithRegistry{}
	bar.registry = &oneReg

	// But this doesn't work:
	// ./main.go:60:15: cannot use &twoReg (type *twoRegistry) as type Registry in assignment:
	// *twoRegistry does not implement Registry (wrong type for Named method)
	// have Named() NamedTwo
	// want Named() Named

	// bar.registry = &twoReg
}

func expectNamed(in Named) {
	fmt.Println("expectNamed:    " + in.Name())
}

func expectNamedTwo(in NamedTwo) {
	fmt.Println("expectNamedTwo: " + in.Name())
}