How do I compare two functions for pointer equality in the latest Go weekly?

by

Note that there is a difference between equality and identity. The operators == and != in Go1 are comparing the values for equivalence (except when comparing channels), not for identity. Because these operators are trying not to mix equality and identity, Go1 is more consistent than pre-Go1 in this respect.

Function equality is different from function identity.

One reason for not allowing == and != on function types is performance. For example, the following closure is not using any variables from its environment:

f := func(){fmt.Println("foo")}

Disallowing comparisons of functions enables the compiler to generate a single implementation for the closure, instead of requiring the run-time to create a new closure (at run-time). So, from performance viewpoint the decision to disallow function comparisons was a good decision.

In relation to using the reflect package to determine function identity, a code like

func SomeFun()    {}
func AnotherFun() {}

func main() {
    sf1 := reflect.ValueOf(SomeFun)
    sf2 := reflect.ValueOf(SomeFun)
    fmt.Println(sf1.Pointer() == sf2.Pointer())  // Prints true

    af1 := reflect.ValueOf(AnotherFun)
    fmt.Println(sf1.Pointer() == af1.Pointer())  // Prints false
}

relies on undefined behavior. There are no guarantees as to what the program will print. The compiler may decide that it will merge SomeFun and AnotherFun into a single implementation, in which case the 2nd print statement would print true. In fact, there is absolutely no guarantee that the 1st print statement will print true (it may, under some other Go1 compiler and run-time, print false).

A correct answer to your original question is:

package main

import "fmt"

func F1() {}
func F2() {}

var F1_ID = F1  // Create a *unique* variable for F1
var F2_ID = F2  // Create a *unique* variable for F2

func main() {
    f1 := &F1_ID  // Take the address of F1_ID
    f2 := &F2_ID  // Take the address of F2_ID

    // Compare pointers
    fmt.Println(f1 == f1)  // Prints true
    fmt.Println(f1 == f2)  // Prints false
}

More Related Contents:

  1. Type converting slices of interfaces
  2. Access struct property by name
  3. Iterate through the fields of a struct in Go
  4. How to compare if two structs, slices or maps are equal?
  5. How to get Type representation from name via reflection?
  6. How do you create a new instance of a struct from its type at run time in Go?
  7. Convert between slices of different types
  8. Instance new Type (Golang)
  9. Identify non builtin-types using reflect
  10. Using reflect, how do you set the value of a struct field?
  11. range over interface{} which stores a slice
  12. Passing an arbitrary function as a parameter in Go
  13. Call a Struct and its Method by name in Go?
  14. How to get the name of a function in Go?
  15. What is the possible use case for defer?
  16. golang get only one stat from json
  17. cancel a blocking operation in Go
  18. Relative imports in Go
  19. What should be the values of GOPATH and GOROOT?
  20. Organizing a multiple-file Go project [closed]
  21. Can I create shared test utilities?
  22. How to get the directory of the currently running file?
  23. Is this casting in golang?
  24. Go-compiled binary won’t run in an alpine docker container on Ubuntu host
  25. Return pointer to local struct
  26. How to import local packages without gopath
  27. How can I open files relative to my GOPATH?
  28. Difference between any/interface{} as constraint vs. type of argument?
  29. Slice chunking in Go
  30. Handle maps with same key type but different value type

Leave a Comment