Plantilla de Golang con interruptor y ForEach

Necesito crearbash.sh archivo del programa golang que debe hacer lo siguiente:

CrearPara cada bucle de dependencias y leer el tipo y de acuerdo con el tipo de impresión diferente mensaje de eco (comandos) Necesito que funcione concambiar sobre eltype de la dependencia con Golang

p.ej. algo como seguir

Para cada entrada de dependencia, agregue el mensaje de tipo echo

#!/bin/bash
for a in $(dependencies.type) 
  echo $runner  //from type 
done

lo que hice es lo siguiente que no funciona

La idea de que para las dependencias escriba"corredor1"(vea el valor de la propiedad de tipo en la instancia de estructura de dependencia) Necesito ejecutarvarios comandos y para"corredor2" Necesito corrervarios comandos diferentesY esos comandos (como echo api1 para runner1, etc.) anteriores deben escribirse en el bash.script que necesito crear a partir de la plantilla

paquete principal

import (
    "fmt"
    "log"
    "text/template"
    "gopkg.in/yaml.v2"
    "os"
)

type File struct {
    TypeVersion string `yaml:"_type-version"`
    Dependency  []Dependency
}

type Dependency struct {
    Name    string
    Type    string
    CWD     string
    Install []Install
}

type Install map[string]string

var data = `
_type-version: "1.0.0"
dependency:
  - name: ui
    type: runner
    cwd: /ui
    install:
       - name: api

  - name: ui2
    type: runner2
    cwd: /ui2
    install:
       - name: api2

`

func main() {
    f := File{}

    err := yaml.Unmarshal([]byte(data), &f)
    if err != nil {
        log.Fatalf("error: %v", err)
    }

    d, err := yaml.Marshal(&f)
    if err != nil {
        log.Fatalf("error: %v", err)
    }
    fmt.Printf("--- t dump:\n%s\n\n", string(d))

    wd, _ := os.Getwd()

    newfile, err := os.Create(wd + "/" + "bash.sh") // Truncates if file already exists
    if err != nil {
        fmt.Errorf("Failed to create file: %s , %s", wd+"/"+"bash.sh", err)
    }

    fmt.Println(newfile)

    const File = `
#!/bin/bash
{{.dependency}},
{{if .Type runner2}}
 echo "type is runner2"
{{- else}}
echo "type is %S"
{{- end}}
{{end}}
`

    t := template.Must(template.New("bash.sh").Parse(File))

    for _, r := range f.Dependency {
        err := t.Execute(os.Stdout, r)
        if err != nil {
            log.Println("executing template:", err)
        }
    }

}

actualizar

Por ejemplo

digamos que he asignado como siguiente y la estructura de dependencias debería funcionar con la estructura de API para saber qué comando ejecutar para cada valor de tipo

API := map[string]string {
{
“runner1” : “api1”,
},
{
“runner2” : “api2”,
}
}

Así es como debería verse el guión al final

#bin/bash

// in context of dep1
echo runner1
submitting api1


// in context of dep2
echo runner2
submitting api2

Respuestas a la pregunta(1)

Su respuesta a la pregunta