Using methods with multiple return values

I'm trying to write a template (using html/template) and passing it a struct that has some methods attached to it, many of which return multiple values. Is there any way of accessing these from within the template? I'd like to be able to do something like:

package main

import (
        "fmt"
        "os"
        "text/template"
)

type Foo struct {
    Name string
}

func (f Foo) Baz() (int, int) {
    return 1, 5
}

const tmpl = `Name: {{.Name}}, Ints: {{$a, $b := .Baz}}{{$a}}, {{b}}`

func main() {

    f := Foo{"Foo"}

    t, err := template.New("test").Parse(tmpl)
    if err != nil {
	    fmt.Println(err)
    }

    t.Execute(os.Stdout, f)

}

But obviously this doesn't work. Is there no way around it?

I've considered creating an anonymous struct in my code:

data := struct {
	Foo
	a	int
	b 	int
}{
	f,
	0,
	0,
}
data.a, data.b = f.Baz()

And passing that in, but would much prefer to have something in the template. Any ideas? I also tried writing a wrapper function which I added to funcMaps but could never get that to work at all.

Thanks for any suggestions!

You won't be able to call a function that returns two values in a template unless one of those values is an error. This is so that your template is guaranteed to work at runtime. There is a great answer that explains that here, if you're interested.

To solve your problem you need to either 1) break your function into two separate getter functions that you can call in the appropriate place in your template; or 2) have your function return a simple struct with the values inside.

I can't tell which would be better for you because I really have no idea what your implementation requires. Foo and Baz don't give many clues.

Here is a quick-n-dirty example of option one:

type Foo struct {
    Name string
}

func (f Foo) GetA() (int) {
    return 1
}

func (f Foo) GetB() (int) {
    return 5
}

And then modify the template accordingly:

const tmpl = `Name: {{.Name}}, Ints: {{.GetA}}, {{.GetB}}`

Hopefully this is of some help.

There is also possibility to return struct with multiple fields and use them.

type Result struct {
    First string
    Second string
}

func GetResult() Result {
     return Result{First: "first", Second: "second"}
}

And then use in template

{{$result := GetResult}}
{{$result.First}} - {{$result.Second}}

I recently had a problem similar to this one and came across this question. I think this might be a little cleaner. It doesn't require you to create multiple new functions:

const tmpl = `Name: {{.Name}}, Ints: {{BazWrapper .}}`

func main() {

    f := Foo{"Foo"}

    funcMap := template.FuncMap{
        "BazWrapper": func(f Foo) string {
            a, b := f.Baz()
            return fmt.Sprintf("%d, %d", a, b)
        },
    }

    t, err := template.New("test").Funcs(funcMap).Parse(tmpl)
    if err != nil {
        fmt.Println(err)
    }

    t.Execute(os.Stdout, f)

}