How to use function as map's key? for example:
type Action func(int)
func test(a int) { }
func test2(a int) { }
func main() {
x := map[Action]bool{}
x[test] = true
x[test2] = false
}
those code would show an error: invalid map key type Action
You cannot use a function as a map key. The language specification clearly says:
The comparison operators == and != must be fully defined for operands of the key type; thus the key type must not be a function, map, or slice.
You can't use functions as keys in maps : the key type must be comparable.
From Go blog :
map keys may be of any type that is comparable. The language spec defines this precisely, but in short, comparable types are boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types. Notably absent from the list are slices, maps, and functions; these types cannot be compared using ==, and may not be used as map key
What you might use, depending on your precise use case, is an interface.
You can use reflect.
import (
"reflect"
"math"
)
func foo () {
table := make(map[uintptr] string)
table[reflect.ValueOf(math.Sin)] = "Sin"
table[reflect.ValueOf(math.Cos)] = "Cos"
println(table[reflect.ValueOf(math.Cos)])
}
While functions can't be keys, function pointers can.
package main
import "fmt"
type strFunc *func() string
func main() {
myFunc := func() string { return "bar" }
m := make(map[strFunc]string)
m[(strFunc)(&myFunc)] = "f"
for f, name := range m {
fmt.Println((*f)(), name)
}
}
You cannot do this directly, as mentioned already, but you can sort of fake it you do something like this:
package main
import "fmt"
func a(i int) int {
return i + 1
}
func b(i int) int {
return i + 2
}
type Function func(int)int
type FunctionWrapper struct {
f *Function
}
var fnMap = make(map[string]FunctionWrapper)
// MakeFunctionWrapper returns a unique FunctionWrapper per Function pointer, using fnMap to avoid having multiple values for the same function
func MakeFunctionWrapper(f Function) FunctionWrapper {
key := fmt.Sprintf("%#v", f)
data, ok := fnMap[key]
if !ok {
data = FunctionWrapper{&f}
fnMap[key] = data
}
return data
}
func main() {
functions := make(map[FunctionWrapper]bool)
fa := MakeFunctionWrapper(a)
fb := MakeFunctionWrapper(b)
fb2 := MakeFunctionWrapper(b)
functions[fa] = true
functions[fb] = true
functions[fb2] = false // This overwrites the previous value since fb is essentially the same as fb2
fmt.Println(functions[fa]) // "true"
fmt.Println(functions[fb]) // "false"
fmt.Println(functions[fb2]) // "false"
}
Check it out on the Go playground
This is a bit cumbersome, and I honestly think it's a very bad idea to essentially use the string version of a pointer as your map's key. But ... it's at least an option if you really need it.
A clean way to achieve this is to wrap the functions in a struct, then use a pointer to this struct as the map key:
type FuncPack struct {
TheFunc func(a int)
}
func Test(a int) {}
func Test2(a int) {}
func main() {
theMap := make(map[*FuncPack]bool)
theMap[&FuncPack{TheFunc: Test}] = true
theMap[&FuncPack{TheFunc: Test2}] = false
}
Use function pointers as map keys instead of functions.
The following example stores dependencies of function in a map, calculates the execution order and executes the functions in the correct order:
package main
import (
"fmt"
)
type Action func()
var Premises = make(map[*Action][]*Action)
func OnSetup(action Action, premises ...*Action) *Action {
ap := &action
Premises[ap] = premises
return ap
}
func rank(action *Action) int {
if len(Premises[action]) == 0 {
return 0
}
max := 0
for _, p := range Premises[action] {
r := rank(p)
if r > max {
max = r
}
}
return max + 1
}
func Setup() {
ranks := make(map[int][]*Action)
for action := range Premises {
r := rank(action)
ranks[r] = append(ranks[r], action)
}
for r := 0; r < len(ranks); r++ {
fmt.Println("Rank:", r)
actions := ranks[r]
for a := range actions {
(*(actions[a]))()
}
}
}
func main() {
a := OnSetup(func() { fmt.Println("a") })
b := OnSetup(func() { fmt.Println("b") }, a)
OnSetup(func() { fmt.Println("c") }, b)
OnSetup(func() { fmt.Println("d") })
Setup()
}
