Als Lernübung schreibe ich eine grundlegende Warteschlangendatenstruktur. Ich habe gestern angefangen, etwas über Schnittstellen zu lernen. Ich dachte, es wäre cool, sie für diese Übung zu verwenden. Was ich versuche zu erreichen, ist ein @ zu habQueue das jeden Typ akzeptieren kann, der diese Schnittstelle implementiert:

type Queuable interface {
  Next() *Queuable  // This is probably not right
}

rundsätzlich möchte ich in der Lage sein, jeden Typ hinzuzufügen, der ein @ hNext() Methode zu meinemQueue. Also, was ich versucht habe, war:

type Node struct {
    value interface{}
    next  *Queuable
}

// Next gets the next object
func (n *Node) Next() *Queuable {
    return n.next
}

// Job - A job for the queue
type Job struct {
    instruction string
    next        *Queuable
}

// Next gets the next object
func (j *Job) Next() *Queuable {
    return j.next
}

// Queue ...
type Queue struct {
    head *Queuable
    size int
}

Und meine Methoden sehen so aus:

func (q *Queue) Enqueue(node *Queuable) {
    ...
}

// Dequeue - Remove a Queueable form the Queue
func (q *Queue) Dequeue() *Queuable {
  result := q.head
  q.head = q.head.Next()
  q.size--
  return result
}

Ich erhalte eine Menge dieser Fehler (im Grunde genommen in jeder Zeile mit einer Zuweisung):

current.Next undefined (type *Queuable is pointer to interface, not interface)

So würde ich letztendlich gerne folgendes tun:

func main() {
  queue := NewQueue()  // Helper function not pictured
  job := &Job{"some instructions", nil}
  node := &Node{5, nil}
  queue.Enqueue(node)  // queue = [node]
  queue.Enqueue(job) // queue = [node, job]
  queue.Dequeue() // node
  queue.Dequeue() // job
}