Alternative for function overloading in Go?

Question

Is it possible to work similar way like the function overloading or optional parameter in C# using Golang? Or maybe an alternative way?

Answer 1

The idiomatic answer to optional parameters in Go is wrapper functions:

func do(a, b, c int) {
    // ...
}

func doSimply(a, b) {
    do(a, b, 42)
}

Function overloading was intentionally left out, because it makes code hard(er) to read.

Answer 2

Neither function overloading nor optional arguments are directly supported. You could work around them building your own arguments struct. I mean like this (untested, may not work...) EDIT: now tested...

package main

    import "fmt"

    func main() {
        args:=NewMyArgs("a","b") // filename is by default "c"
        args.SetFileName("k")

        ret := Compresser(args)
        fmt.Println(ret)
    }

    func Compresser(args *MyArgs) string {
        return args.dstFilePath + args.srcFilePath + args.fileName 
    }

    // a struct with your arguments
    type MyArgs struct 
    {
        dstFilePath, srcFilePath, fileName string 
    }

   // a "constructor" func that gives default values to args 
    func NewMyArgs(dstFilePath string, srcFilePath string) *MyArgs {
        return &MyArgs{
              dstFilePath: dstFilePath, 
              srcFilePath:srcFilePath, 
              fileName :"c"}
    }

    func (a *MyArgs) SetFileName(value string){
      a.fileName=value;
    }

Answer 3

There are some hints here using variadic arguments, for example:

sm1 := Sum(1, 2, 3, 4) // = 1 + 2 + 3 + 4 = 10
sm2 := Sum(1, 2) // = 1 + 2 = 3
sm3 := Sum(7, 1, -2, 0, 18) // = 7 + 1 + -2 + 0 + 18 = 24
sm4 := Sum() // = 0

func Sum(numbers ...int) int {    
    n := 0    
    for _,number := range numbers {
        n += number
    }    
    return n
}

Or ...interface{} for any types:

Ul("apple", 7.2, "BANANA", 5, "cHeRy")

func Ul(things ...interface{}) {
  fmt.Println("<ul>")    
  for _,it := range things {
    fmt.Printf("    <li>%v</li>\n", it)
  }    
  fmt.Println("</ul>")
}

Answer 4

An approach I use sometime for constructing an object using New methods having different arguments is to have a "flavor" pseudo type. You can try it on the Go Playground https://play.golang.org/p/5To5AcY-MRe

package main

import "fmt"

type flavorA struct{}
type flavorB struct{}

var FlavorA = flavorA{}
var FlavorB = flavorB{}

type Something struct {
    i int
    f float64
}

func (flavor flavorA) NewSomething(i int) *Something {
    return &Something{i:i, f:0.0}
}

func (flavor flavorB) NewSomething(f float64) *Something {
    return &Something{i:0, f:f}
}

func main() {
    fmt.Println(FlavorA.NewSomething(1), FlavorB.NewSomething(2))
}

Answer 5

When you have many arguments it may make sense to use a new struct for them or to define a new MyOptionBuilder type to build and store all the arguments and to construct nice defaults.

Here's a simple example where the go defaults for types are okay.

package main

import "fmt"

type FancyFuncOptions struct {
    I int64
    S string
    F float64
    //...many more...
}

func FancyFunc(opts *FancyFuncOptions) {
    fmt.Println("%v", opts)
}

func main() {
    // simple way
    options := &FancyFuncOptions{S: "happy"}
    FancyFunc(options)

In golang you'll see people using method-chaining for this, if the options have complex logic.

package main

import "fmt"

type FancyFuncOptions struct {
    I int64
    S string
    F float64
    //...many more...
}

// chaining style
func NewFancyFuncOptions() *FancyFuncOptions {
    return &FancyFuncOptions{I: 100, S: "empty", F: 0.1}
}

func (o *FancyFuncOptions) SetI(i int64) *FancyFuncOptions {
    o.I = i
    return o
}

func (o *FancyFuncOptions) SetS(s string) *FancyFuncOptions {
    o.S = s
    return o
}

func FancyFunc(opts *FancyFuncOptions) {
    fmt.Println("%v", opts)
}

func main() {
    // fancier
    options = NewFancyFuncOptions().SetI(234).SetS("happy")
    FancyFunc(options)

(https://go.dev/play/p/Ae_6Y6kZa97)

Make sense?