общая функция для динамического создания структуры map [string] из фрагмента struct

Question

У меня есть две разные структуры, как указано ниже A abd B и две функции процесса.Есть ли способ, с помощью которого я могу написать общую функцию для генерации map[string]struct для обоих struct.Кроме того, есть ли способ с помощью отражения, учитывая имя структуры, я могу создать такой же объект?

type A struct {
    name string
    // more fields
}


type B struct {
    name string
    // more fields  
}

func ProcessA(input []A) map[string]A {
    output := make(map[string]A)
    for _, v := range input {
         output[v.name] = v
    }
  return output
}


func ProcessB(input []B) map[string]B {
    output := make(map[string]B)
    for _, v := range input {
         output[v.name] = v
    }
  return output
}

Answer 1

Хорошо, посмотрите, поможет ли что-то подобное:

package main

import (
    "fmt"
    "strconv"
)

type A struct {
    name string
    // more fields
}

type B struct {
    name string
    // more fields
}

func Process(x interface{}) interface{} {
    ma := make(map[string]int)
    mb := make(map[string]string)

    if x == nil {
        return nil
    } else if a, ok := x.([]A); ok {
        fmt.Printf("Type A argument passed %s\n", x)
        ma[a[0].name] = 1
        ma[a[1].name] = 2
        return ma //you can return whatever type you want here
    } else if b, ok := x.([]B); ok {
        fmt.Printf("Type B argument passed %s\n", x)
        mb[b[0].name] = "a"
        mb[b[1].name] = "b"
        return mb //you can return whatever type you want here
    } else {
        panic(fmt.Sprintf("Unexpected type %T: %v", x, x))
    }
    return nil
}

func main() {
    a := make([]A, 5)
    for i := 0; i < len(a); i++ {
        a[i].name = strconv.Itoa(i) + "A"
    }
    b := make([]B, 7)
    for i := 0; i < len(b); i++ {
        b[i].name = strconv.Itoa(i) + "B"
    }

    fmt.Println(Process(a))
    fmt.Println(Process(b))
    //Uncomment line below to see the panic
    //fmt.Println(Process(8))

}

https://play.golang.org/p/irdCsbpvUv_t

Answer 2

Идиоматическим способом в Go было бы использование интерфейса.

type Named interface {
  Name() string
}

type letter struct {
  name string
}

func (l letter) Name() string {
  return l.name
}


type A struct {
    letter
    // more fields
}


type B struct {
    letter
    // more fields  
}

func ProcessNameds(input []Named) map[string]Named {
    output := make(map[string]Named, len(input))
    for _, v := range input {
         output[v.Name()] = v
    }
  return output
}