我尝试了反射方法，以下是我能够实现的解决方案：
https://go.dev/play/p/MPBOmQAmECl
(it使用编解码器的动态Map，而不是在函数中硬编码所有内容）
对我来说还是太复杂了。我的意思是，我一直认为，如果其他方法都失败了，使用反射将是解决方案，但我的问题似乎太简单了，以至于这个解决方案似乎是错误的，至少直观上是错误的。另外，在这种方法中，仍然需要为所有int / uint和float类型实现解码器函数

package main

import (
    "bytes"
    "encoding/binary"
    "fmt"
    "reflect"
)

// decoder function receives a source byte slice and a destination pointer
// it returns number of bytes that have been parsed and optionally an error
type Decoder func(src []byte, dest reflect.Value, structField reflect.StructField) (int, error)

type BinaryDecoder struct {
    Codecs map[reflect.Kind]Decoder
}

func (d *BinaryDecoder) Unpack(src []byte, dst interface{}) (int, error) {
    return d.unpackRecursive(src, dst, reflect.StructField{})
}

func (d *BinaryDecoder) unpackRecursive(src []byte, dst interface{}, structField reflect.StructField) (int, error) {
    var bytesRead int = 0
    var err error

    dstValue := reflect.ValueOf(dst)
    dstType := dstValue.Type()

    if dstValue.Kind() == reflect.Ptr {
        dstValue = dstValue.Elem()
        dstType = dstType.Elem()
    }

    valueType := dstValue.Kind()

    switch valueType {
    case reflect.Struct:
        // let's unpack the struct field by field.
        for i := 0; i < dstValue.NumField(); i += 1 {
            structField := dstValue.Field(i)
            fmt.Printf("%d'th field has a name of %s and is of type %v\n", i, structField.Type().Name(), structField.Kind())
            fmt.Printf("bin tag: %v\n", dstType.Field(i).Tag.Get("bin"))
            if bytesRead, err = d.unpackRecursive(src, structField.Addr().Interface(), dstType.Field(i)); err != nil {
                return -1, fmt.Errorf("unable to unpack struct: %v", err)
            }
            fmt.Printf("Read %d bytes from %s\n", bytesRead, structField.Type().Name())
            src = src[bytesRead:]
        }
    case reflect.Array:
        declaredSize := dstType.Size()
        fmt.Printf("begin to unpack array; declaredSize=%d\n", declaredSize)
        for i := 0; i < int(declaredSize); i += 1 {
            if bytesRead, err = d.unpackRecursive(src, dstValue.Index(i).Addr().Interface(), structField); err != nil {
                return -1, fmt.Errorf("unable to unpack array at position %d: %v", i, err)
            }
            src = src[bytesRead:]
        }

    default:
        decoder, exists := d.Codecs[valueType]
        if !exists {
            return -1, fmt.Errorf("unsupported value type: %v", valueType)
        }

        return decoder(src, dstValue, structField)
    }

    return bytesRead, nil
}

type NestedStruct struct {
    PasString string `bin:"p"`
}

type BinaryStruct struct {
    IntField uint16
    Nested   NestedStruct
    Array    [10]byte
}

func decodeUint8(src []byte, dest reflect.Value, structField reflect.StructField) (int, error) {
    dest.SetUint(uint64(src[0]))
    return 1, nil
}

func decodeUint16(src []byte, dest reflect.Value, structField reflect.StructField) (int, error) {
    var tmpVal uint16
    if err := binary.Read(bytes.NewReader(src), binary.LittleEndian, &tmpVal); err != nil {
        return -1, fmt.Errorf("unable to decode uint16: %v", err)
    }
    dest.SetUint(uint64(tmpVal))
    return 2, nil
}

func decodeString(src []byte, dest reflect.Value, structField reflect.StructField) (int, error) {
    if structField.Tag.Get("bin") != "p" {
        return -1, fmt.Errorf("unsupported string type")
    }
    declaredLength := int(src[0])
    dest.SetString(string(src[1 : declaredLength+1]))

    return declaredLength + 1, nil
}

func main() {
    var srcBytes = []byte{
        0x00, 0x01, // uint16
        0x04, 0x41, 0x41, 0x41, 0x41, // string
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, // array of 10 bytes
    }

    var bin BinaryStruct
    var numBytes int
    var err error

    decoder := &BinaryDecoder{
        Codecs: map[reflect.Kind]Decoder{
            reflect.Uint8:  decodeUint8,
            reflect.Uint16: decodeUint16,
            reflect.String: decodeString,
        },
    }

    numBytes, err = decoder.Unpack(srcBytes, &bin)

    if err != nil {
        fmt.Printf("Error unpacking structure: %v\n", err)
    }

    fmt.Printf("Read %d bytes; end structure: %+v\n", numBytes, bin)
}