/cc @rsc @robpike

I'm not experienced with the text/template package, but since this issue has had little attention, I've played a bit with it.

@bep, I think this is working as intended - even though from a user's point of view it's a bit unintuitive.

Reading the package godoc:

.Field
The result is the value of the field.
.Method
The result is the value of invoking the method with dot as the receiver, dot.Method().

Note that, in your example, both a.Method and a.Func have type func() []string.

So, following the package's own godoc, it makes sense that {{ range .Method }} would equate range []string{...}, while {{ range .Func }} would equate range func() []string { return ... }.

You can also fix this by using call, i.e. {{ range call .Func }}.

So I would say this is not a bug in the sense that the package is not broken. You could argue that it could be made more user-friendly, but it could also lead to more complex rules. And it would probably warrant a proposal, not a bug report.

It is a little confusing but yes it is working as intended. Use 'call'.

Just in case other people are slow thinking as myself. I just figured out a workaround that is so obvious that I'm a little bit embarrassed showing it:

My use case was/is:

I had a map sent to the templates with some data that was rarely used, so I wanted to lazily load it without messing with the API (i.e. the map key/value range etc.).

The workaround is, of course, to create a map type with methods:

package main

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

type MyMap map[string]interface{}

func (m MyMap) MyFunc() string {
	f := m["func"].(func() string)
	return f()
}

func main() {

	m := make(MyMap)

	m["func"] = func() string {
		return "Hello"
	}

	tpl := "{{ .MyFunc }}"

	var buf bytes.Buffer
	tmpl, err := template.New("").Parse(tpl)
	if err != nil {
		panic(err)
	}
	if err := tmpl.Execute(&buf, m); err != nil {
		panic(err)
	}

	fmt.Println(buf.String())

}

The above example is a little bit constructed, but it shows the point, I hope.