[go-nuts] Delegates in Go and Inner in the Beta programming language

I prefer the way which is clearer and easier to understand and does not
need any new keywords:

package main

import "fmt"

type Magician interface {

Magic()

}

type Base struct{

magician Magician

}

func (Base) Magic() {

fmt.Print("base magic")

}

func (self Base) MoreMagic() {

self.magician.Magic()

self.Magic()

}

type Foo struct {

Base

}

func (Foo) Magic() {

fmt.Print("foo magic")

}

func main() {

f := new(Foo)

f.magician = f

f.MoreMagic()

}

In your solution Base does not need to implement Magician as in other
languages since in Go interfaces are implicitly derived. This feature is
really powerfull. Otherwise the coding effort would be much harder and
things could not be made transparent. Thanks for your solution.


func (delegate Delegate) Magic() {
Does this incur a runtime penalty? Only asking, because I'm still a Go
novice and don't know ...

-- Saxo

novice and don't know ...

http://en.wikipedia.org/wiki/Duck_typing

Since delegate.magician already has type Magician, the only way that ok
could be false is if delegate.magician were nil. Best to just check "if
delegate.magician != nil" instead.
The first time you assert a particular concrete type contained in one
interface to another interface (perhaps in your example the compiler can
skip this), it does a comparison of the method sets of the interface and
the concrete type. After that, it can do a fast lookup.

You can check, the Foo implemented Magic or not.

package main

import (
"fmt"
)

type Magician interface {
Magic()
}

type Delegate struct{
magician Magician
}

func (delegate Delegate) Magic() {
if _, ok := delegate.magician.(Magician); ok {
delegate.magician.Magic()
} else {
fmt.Println("base magic")
}
}

func (delegate Delegate) MoreMagic() {
delegate.magician.Magic()
delegate.magician.Magic()
}

type Foo struct {
Delegate
}

func (foo Foo) Magic() {
fmt.Println("foo magic")
}

func main() {
f := Delegate{new(Foo)}
f.Magic() // if remove implement of Foo.Magic, it will show 'base magic'
f.MoreMagic()
}

That doesn't print anything. It won't even compile.
I assume the intent was to call ".Magic()" on f. Like this:

http://play.golang.org/p/EGZVPHPYpa

That prints "foo magic", indicating that the function of the
derived class (OK, in Go jargon "method bound to a struct type
which uses Base as an anonymous field") was called instead of
the one for Base.

That's what should happen. What's the problem?

John Nagle

Some lines of code were missing. It should be:

f := new(Foo)
The sample is taken from http://www.infoq.com/articles/google-go-primer

-- Saxo