[go-nuts] Is this acceptable Interface usage

That depends: If Consumer and Producer are always Endpoints it
seem more natural to me to embed an Enpoint:

type Endpoint interface {
     Name() string
     Type() string
}

type Consumer interface {
      Endpoint
      // consumer-only methods here
}

I am not sure if I like the IsConsumer or IsProducer methods:
Such can be queried by a type switch or cast. (What would
happen if a Consumer answers with false to IsConsumer?)
If this needs to be a method: Why not as part of Enpoint?

V.

Hi Eric,

You could embed the Endpter interface in the two others. See:
http://play.golang.org/p/BUu1xO57OW

IsProducer and IsConsumer methods seem a little strange but I don't know
anything else about the code. Otherwise it's looking good.

Regards,
Henry Heikkinen


2013/5/22 Eric Palmer <eric@ericfpalmer.com>

Thanks to both of you. Consumers and Producers are always and Endpoint.

IsConsumer() and IsProducer() were dirty methods because I had not figured
out how to do that with reflection yet.

Embedding these into Endpter will be useful.

Eric

You don't need reflection--at least as in reflect package--to do that. See
type assertions: http://golang.org/ref/spec#Type_assertions

Regards,
Henry Heikkinen


2013/5/22 Eric Palmer <eric@ericfpalmer.com>

Even better.

thanks

Go does not support method overloading, se this famous example from here<http://www.infoq.com/articles/google-go-primer>
:

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() // ==> foo magicbase magic
}

When run this will print "foo magicbase magic". So in your Consumer and
Producer you will have to implement both IsConsumer() and IsProducer()
retruning each true or false as required.

-- Bienlein

would it be possible to model this using structs?
See: http://golang.org/doc/effective_go.html#embedding

I'm not really sure whether I understand what you are asking for. But I
just realized that what in my reply was this:

func main() {

was the trick that would do what you would like to do, see this<https://groups.google.com/forum/?hl=de&fromgroups=#!topic/golang-nuts/yM2JguyucM0>thread. To correct my mistake the example from the go
primer <http://www.infoq.com/articles/google-go-primer> has this sample
code:

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



package main

import "fmt"

type EndPt interface {
  Name() string
  Type() string
}

type myEndPt struct {
  _name string
  _type string
}

func (e *myEndPt) Name() string { return e._name }
func (e *myEndPt) Type() string { return e._type }
func (e *myEndPt) String() string { return "name = " + e._name + "\ntype
= " + e._type }

type Consumer struct {
  *myEndPt
}

type Producer struct {
  *myEndPt
}

type MindTheGap interface {
  EndPt
}

func main() {
  var c EndPt = Consumer{&myEndPt{"consumer name", "consumer type"}}
  var p EndPt = Producer{&myEndPt{"producer name", "producer type"}}

  _, isConsumer := c.(Consumer)
  _, isProducer := p.(Producer)
  _, isMindTheGap := p.(MindTheGap)

  fmt.Println("isConsumer =", isConsumer)
  fmt.Println(c)

  fmt.Println()

  fmt.Println("isProducer =", isProducer)
  fmt.Println(p)

  fmt.Println()

  fmt.Println("isMindTheGap =", isMindTheGap)
  fmt.Println(p)
}

What about this one:

package main

import "fmt"

type EndPt interface {
     Name() string
     Type() string
     IsConsumer() bool
     IsProducer() bool
}

type myEndPt struct {
     _name string
     _type string
}

type Consumer struct {
     *myEndPt
}


func (self Consumer) IsConsumer() bool {
     return true
}

func (self Consumer) IsProducer() bool {
     return false
}

type Producer struct {
     *myEndPt
}

func (self Producer) IsConsumer() bool {
     return false
}

func (self Producer) IsProducer() bool {
     return true
}


func main() {
     consumer := new(Consumer)
     producer := new(Producer)

     fmt.Println("isConsumer =", consumer.IsConsumer())
     fmt.Println("isConsumer =", consumer.IsProducer())

     fmt.Println()

     fmt.Println("isProducer =", producer.IsProducer())
     fmt.Println("isConsumer =", producer.IsConsumer())
}

What would be the need to define isConsumer and isProducer?
Go already provides the means to test the type.

Just because I hadn't gotten to that point in my learning. They have been
ripped out of the code already.

thanks

Eric

Sorry, I hope my quick reply didn't come across as rude.

Not at all.

Make use of OO message sends. The reason you have to do instanceof in Java
is because Java does not have extension methods. So you could not add a
method isProducer() to some common super class in case you don't own it.
This way you have to revert to instanceof as a last resort. This made
people believe that instanceof is a proper way of checking the type, but it
is only a practical workaround in case OO message sends don't work.

My previous code can be made much smarter:

package main

import "fmt"

type EndPt struct {

}

func (self EndPt) IsConsumer() bool {
     return false
}

func (self EndPt) IsProducer() bool {
     return false
}

type Consumer struct {
     EndPt
}

func (self Consumer) IsConsumer() bool {
     return true
}

type Producer struct {
     EndPt
}

func (self Producer) IsProducer() bool {
     return true
}


func main() {
     consumer := new(Consumer)
     producer := new(Producer)

     fmt.Println("isConsumer =", consumer.IsConsumer())
     fmt.Println("isProducer =", consumer.IsProducer())

     fmt.Println()

     fmt.Println("isProducer =", producer.IsProducer())
     fmt.Println("isConsumer =", producer.IsConsumer())
}