How can I write a function that takes either one of many types in go?

I'm trying go for a small project and tried to write these functions:

func fatal(reason string) {
	println(reason)
	os.Exit(1)
}

func fatal(err error) {
	fatal(err.Error())
}

After digging about a bit and finding this answer, which referenced the docs on overloading I realised that what I was trying to do was illegal in go.

What I want is a simple api that allows me to call fatal with either a string or an error in order to simplify my logic. How do I achieve this or a similar goal?

It would feel inelegant to have func fatal(reason string) along with func fatalErr(err error), is that what's needed? Am I missing a different feature of the language that allows me to do what I want?

The most common way to do this would be to define the method as func fatal(err interface{}) then do type assertions or use a type switch within it's body to handle each of the different types. If I were coding for your example it would look like this;

func fatal(err interface{}) {
     if v, ok := err.(string); ok {
         fmt.Println(v)
     }
     if v, ok := err.(error); ok {
          fmt.Println(v.Error())
     } else {
        // panic ?
     }
}

Also; here's a quick read about type switches and assertions that may be helpful; http://blog.denevell.org/golang-interface-type-assertions-switch.html
You can also check out effective-go as it has sections on both features.

Use log.Fatal() instead. https://golang.org/pkg/log/#Fatal

You can use interface{} but it is not recommended because you lose all the benefits of type checking when you do that. The Go authors get to use interface{} because they understand the appropriate level of additional testing and checks to do when using interface{}. It's much easier (even for intermediate and advanced gophers) to use builtin and standard library functions when something like this is required.

Go does not have algebraic or/sum types either. The standard workaround is to define an and/product type with pointers (e.g. struct{*string, *error}) and go to the effort of making sure you only ever make one of the fields non nil at any point in time.

Function overloading is not supported in the language. From the official Golang site it says,

<blockquote>Method dispatch is simplified if it doesn't need to do type matching as well. Experience with other languages told us that having a variety of methods with the same name but different signatures was occasionally useful but that it could also be confusing and fragile in practice. Matching only by name and requiring consistency in the types was a major simplifying decision in Go's type system.

Regarding operator overloading, it seems more a convenience than an absolute requirement. Again, things are simpler without it.</blockquote>

https://golang.org/doc/faq#overloading

One potential solution would be to define a high level function that type checks and handles different types similarly to how you would overload multiple functions. See @evanmcdonnal's solution for a great example.