Go语言中如何重构函数以实现跨类型复用

package main

import "fmt"

// Loadable 接口，定义了 Load 方法
type Loadable interface {
    Load([]interface{})
}

// Foo 结构体
type Foo struct {
    Name string
}

// FooList 结构体
type FooList struct {
    Foos []*Foo
}

// 实现 Loadable 接口
func (f *Foo) Load(vals []interface{}) {
    if len(vals) > 0 {
        f.Name = vals[0].(string) // 类型断言，将 interface{} 转换为 string
    }
}

// FooList 实现 Load 方法
func (fl *FooList) Load(vals []interface{}) {
    fl.Foos = make([]*Foo, len(vals))
    for i, v := range vals {
        foo := &Foo{}
        foo.Load(v.([]interface{}))
        fl.Foos[i] = foo
    }
}

// Bar 结构体
type Bar struct {
    Value int
}

// BarList 结构体
type BarList struct {
    Bars []*Bar
}

// Bar 实现 Loadable 接口
func (b *Bar) Load(vals []interface{}) {
    if len(vals) > 0 {
        b.Value = vals[0].(int) // 类型断言，将 interface{} 转换为 int
    }
}

// BarList 实现 Load 方法
func (bl *BarList) Load(vals []interface{}) {
    bl.Bars = make([]*Bar, len(vals))
    for i, v := range vals {
        bar := &Bar{}
        bar.Load(v.([]interface{}))
        bl.Bars[i] = bar
    }
}

func main() {
    fooList := &FooList{}
    fooData := []interface{}{
        []interface{}{"Foo1"},
        []interface{}{"Foo2"},
    }
    fooList.Load(fooData)

    fmt.Println(fooList)

    barList := &BarList{}
    barData := []interface{}{
        []interface{}{123},
        []interface{}{456},
    }
    barList.Load(barData)

    fmt.Println(barList)
}