Gehen Sie Sortieren eine Scheibe Runen?

Verwenden Sortieren.Sortieren(Daten-Schnittstelle) und implementieren Sortieren.Schnittstelle, siehe die Beispiele auf der package-Dokumentation.

Können Sie nicht verwenden rune die int32 als int. Überprüfen Sie die Kommentar von int.

int ist eine vorzeichenbehaftete integer-Typ, die mindestens eine Größe von 32 bit. Es ist ein
distinct-Typ, aber, und nicht ein alias für, sagen wir, int32.

Nur als Vergleich, hier ist, was die Dinge Aussehen könnten, wenn die Art interface etwas anders. Das heißt, anstatt die Schnittstelle wird auf der container, was würde die Dinge Aussehen, wenn die Schnittstelle wurden auf der Elemente statt?

package main

import (
    "fmt"
    "sort"
)

type Comparable interface {
    LessThan(Comparable) bool
}

type ComparableSlice []Comparable

func (c ComparableSlice) Len() int {
    return len(c)
}

func (c ComparableSlice) Less(i, j int) bool {
    return c[i].LessThan(c[j])
}

func (c ComparableSlice) Swap(i, j int) {
    c[i], c[j] = c[j], c[i]
}

func SortComparables(elts []Comparable) {
    sort.Sort(ComparableSlice(elts))
}

//////////////////////////////////////////////////////////////////////
//Let's try using this:

type ComparableRune rune

func (r1 ComparableRune) LessThan(o Comparable) bool {
    return r1 < o.(ComparableRune)
}

func main() {
    msg := "Hello world!"

    comparables := make(ComparableSlice, len(msg))
    for i, v := range msg {
        comparables[i] = ComparableRune(v)
    }

    SortComparables(comparables)

    sortedRunes := make([]rune, len(msg))
    for i, v := range comparables {
        sortedRunes[i] = rune(v.(ComparableRune))
    }

    fmt.Printf("result: %#v\n", string(sortedRunes))
}

Hier definieren wir eine Comparable - Schnittstelle, und wir bekommen unsere Art ComparableRune es zu befriedigen. Aber weil es eine Schnittstelle, die wir zu tun haben, die peinliche Boxen gehen aus rune zu ComparableRune so dass dynamische dispatch-kick im:

    comparables := make(ComparableSlice, len(msg))
    for i, v := range msg {
        comparables[i] = ComparableRune(v)
    }

und unboxing zu wieder unsere Runen:

    sortedRunes := make([]rune, len(msg))
    for i, v := range comparables {
        sortedRunes[i] = rune(v.(ComparableRune))
    }

Dieser Ansatz erscheint uns zu wissen, wie zu tun Typumwandlungen hin und her gehen zwischen der Schnittstelle und der dynamische Typ des Werts. Es scheint, wie wir Sie brauchen würden, um mehr Teile zu Gehen---weitere mechanik---als der Ansatz verwendet, die container als Schnittstelle.