golang中的常规切片类型？

Question

I'm having some difficulties trying to extend slice types into a general type in Go. I have created a sample code to explain my problem. play ground version

package main

import "fmt"

type Sequencer interface {
    Mean() float64
}

type Sequence []int

func (s Sequence) Mean() float64 {
    sum := 0.0
    for _, el := range s {
        sum += float64(el)
    }
    return sum / float64(len(s))
}

func main() {
    a := []int{1, 2, 3, 4}
    b := Sequence(a)
    fmt.Println(b.Mean())
    fmt.Println(b[:2].Mean())
    c := Sequencer(b)
    fmt.Println(c.Mean())
    fmt.Println(c[:2].Mean())
}

Last line of the main() function returns an error saying that variables of type Sequencer cannot be sliced:

cannot slice c (type Sequencer)

Is there a way of defining a general type of slices (int, float64, string,...) without hiding the cool indexing capabilities of slices?

Answer 1

You have

type Sequencer interface {
    Mean() float64
}

c := Sequencer(b)

Therefore, the variable c contains a value of some type which satisfies the Sequencer interface; the type has a Mean method. That's all we can say, no more, no less. It does not imply that the variable c value can be sliced. Therefore, the slice expression c[:2] is invalid. For example, we could define a type Map which satisfies the Sequencer interface but cannot be sliced. If you want to slice c then assert that it is of a type that can be sliced, for example, c.(Sequence)[:2] .

package main

import "fmt"

type Sequencer interface {
    Mean() float64
}

type Sequence []int

func (s Sequence) Mean() float64 {
    sum := 0.0
    for _, el := range s {
        sum += float64(el)
    }
    return sum / float64(len(s))

}

type Map map[string]float64

func (m Map) Mean() float64 {
    sum := 0.0
    for _, v := range m {
        sum += float64(v)
    }
    return sum / float64(len(m))

}

func main() {
    a := []int{1, 2, 3, 4}
    b := Sequence(a)
    fmt.Println(b.Mean())
    fmt.Println(b[:2].Mean())
    c := Sequencer(b)
    fmt.Println(c.Mean())
    fmt.Println(c.(Sequence)[:2].Mean())
    m := Map{"one": 3.14159, "two": 2.718}
    fmt.Println(m.Mean())
}

Output:

2.5
1.5
2.5
1.5
2.929795

Answer 2

Any type that provides the methods declared in an interface definition can be stored in an interface variable of that type. While the actual value you are storing is a slice, any type could implement the interface. And since in many cases it is impossible to statically determine the dynamic type of an interface variable, the language doesn't let you peek below the covers without an explicit type assertion.

If slicing is something you expect types implementing your Sequencer type to implement, then the simple solution is to extend the interface to include such a method:

type Sequencer interface {
    Mean() float64
    Slice(start, end int) Sequencer
}

This can be implemented for your Sequence type in the obvious way:

func (s Sequence) Slice(start, end int) Sequencer {
    return s[start:end]
}

You can then get the mean of a slice using the method:

fmt.Println(c.Slice(0, 2).Mean())

You can experiment with this solution here: http://play.golang.org/p/UMuqOarLUu

Answer 3

Of course. This is no different from any other language that has the concept of an interface.

You're trying to call the "operator" [] on a type that doesn't support it - Sequencer (an interface). Whereas, Sequence does - because it takes on the properties of a slice, hence why the calls to b.Mean and b[:] work.

If this were C# for example, you're essentially trying this:

interface Sequencer {
    float Mean();
}

Sequencer c = ...;

c[any_index] ... // error - interface doesn't have this operator defined

The limitation here is that you cannot implement operator overloads in Go. If you could - then you would be able to just add that to the interface and all would tick along as expected.