go how to check if a function exists

Is there any way to check if a func exists in Go?

In PHP I might do something like

if(function_exists('someFunction')) {
    //...
}

but I have not been able to figure out how to do this in Go

Any help on this will be greatly received.

A little more context on what you're trying to do would help.
As you note in your own comment, if you try to call a function Go checks at compile-time if the function exists, most of the times.

One exception that comes to my mind is when you use interface{} and you want to check that a method exists before calling it. For this you can use type checks.

Example:

package main

import "fmt"

// a simple Greeter struct
// with a Hello() method defined
type Greeter struct {
  	Name string	
}
func (m *Greeter) Hello() string {
	return "hello " + m.Name
}

var x interface{}

func main() {
	x = Greeter {Name:"Paolo"} // x is a interface{}
	g,ok := x.(Greeter) // we have to check that x is a Greeter...
	if ok {
		fmt.Println(g.Hello()) // ...before being able to call Hello()
	}
} 

Another scenario I can think of is that you're creating your own tool for Go that requires parsing go files before compiling them. If so, Go provides help in the for of the parser package

There's no way to do that (and for good!). The reason is that Go is a compiled language and does not support loadable modules (yet, at least) so functions can't come and go at runtime, and hence whether or not a top-level function exists, you know by defintion: if a given source file imports a package containing the function of interest¹, that function is visible in this source file. Or this function is declared in the same package this source file belongs to and hence it's also available. In all the other cases the function is not available. Note that a function might be compiled in the program but still not visible in a given source file while compiling, so the whole definition of visibility as you put it does not exist in Go.

On the other hand you might want some generality. Generality in Go is achieved via interfaces. You might define an interface and then require a type to implement it. Checking that a type implements an interface is done via a neat trick.

An update from 2021-12-29.
The support for loadable modules was added in Go 1.8 in the form of the plugin package and has since then matured to support most mainline platforms except Windows.
Still, this solution is not without problems—for instance, see #20481.

¹Without renaming that module to nothing, but let's not touch this for now.

Provided your thing is an interface value, type assert, something like this:

if Aer, ok := thing.(interface{MethodA()}); ok { 
  Aer.MethodA() 
} 

If thing is a struct, assign it to an interface variable first,
because type assertions only work on interface values.

It wouldn't hurt to define a named interface instead of using the
nonce one, but for simple cases like this it's not worth it.

Recently I had a need for figuring out if a struct has a particular function or not.
Here is another way using reflection :

package main
     
import (
    "fmt"
    "reflect"
)

type FuncRegistry struct {}
  
func (fr FuncRegistry) Hi() {
    fmt.Println("function Hi")
}

func (fr FuncRegistry) Hello() {
    fmt.Println("function Hello")
}

func functionExists(obj interface{},funcName string) bool { 
     mthd := reflect.ValueOf(obj).MethodByName(funcName)
     if mthd.IsValid() { 
         fmt.Printf("Function '%s' exists \n",funcName)
         return true 
     } 
     
     fmt.Printf("Function '%s' does not exist\n",funcName)
     return false 
} 

// Main function
func main() {
    var fr FuncRegistry
    functionExists(fr,"Hi")
    functionExists(fr,"Hello")
    functionExists(fr,"Fail")
}

This sounds a lot like a XY problem. Please tell what you are trying to do. As far as I know, this is something you can't really do the same way as in PHP.

However, you could create a map with function names as keys. Add the functions there manually or generate the contents by parsing the source files before the compilation or at run time. Parsing the source seems like a dirty hack though.