Alternative for function overloading in Go?

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

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.

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;
    }

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>")
}

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))
}

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?