add variadic functions examples

Author: steevehook

Diff for: .DS_Store

@@ -0,0 +1 @@
+.idea/

Diff for: .gitignore

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+	say1("1", "2", "3", "\n")
+	say1(append([]string{"1", "2", "3"}, append([]string{}, "4", "5", "6", "\n")...)...)
+
+	say2("1", "2", "3", "\n")
+	args := []interface{}{"4", "5", "6"}
+	say2(args...)
+}
+
+func say1(args ...string) {
+	for _, a := range args {
+		fmt.Print(a)
+	}
+}
+
+// individual arguments can be of any type
+// destructured slice arguments have to be of type interface{}
+func say2(args ...interface{}) {
+	fmt.Print(args...)
+}

Diff for: 0-basic-variadic-example/main.go

@@ -0,0 +1,36 @@
+package main
+
+var commands = map[string]Command{}
+
+func main() {
+	// create new command
+	command := cmd("get", "get todo by id", []string{"id"})
+	command.Execute()
+
+	// get the existing command
+	command = cmd("get", "", nil)
+	command.Execute()
+}
+
+func cmd(name, description string, args []string) Command {
+	c, ok := commands[name]
+	if ok {
+		return c
+	}
+	c = Command{
+		Name:        name,
+		Description: description,
+		Args:        args,
+	}
+	commands[name] = c
+	return c
+}
+
+type Command struct {
+	Name        string
+	Description string
+	Args        []string
+}
+
+func (c Command) Execute() {
+}

Diff for: 1-cmd-no-variadic/.DS_Store

@@ -0,0 +1,40 @@
+package main
+
+var commands = map[string]Command{}
+
+func main() {
+	// create new command
+	command := createCmd("get", "get todo by id", []string{"id"})
+	command.Execute()
+
+	// get the existing command
+	command = getCmd("get")
+	command.Execute()
+}
+
+func createCmd(name, description string, args []string) Command {
+	c := Command{
+		Name:        name,
+		Description: description,
+		Args:        args,
+	}
+	commands[name] = c
+	return c
+}
+
+func getCmd(name string) Command {
+	c, ok := commands[name]
+	if ok {
+		return c
+	}
+	return Command{}
+}
+
+type Command struct {
+	Name        string
+	Description string
+	Args        []string
+}
+
+func (c Command) Execute() {
+}

Diff for: 1-cmd-no-variadic/main.go

@@ -0,0 +1,47 @@
+package main
+
+var commands = map[string]Command{}
+
+func main() {
+	// create new command
+	command := cmd(Args{
+		Name:        "get",
+		Description: "get todo by id",
+		Args:        []string{"id"},
+	})
+	command.Execute()
+
+	// get the existing command
+	command = cmd(Args{Name: "get"})
+	command.Execute()
+}
+
+type Args struct {
+	Name        string
+	Description string
+	Args        []string
+}
+
+func cmd(args Args) Command {
+	c, ok := commands[args.Name]
+	if ok {
+		return c
+	}
+
+	c = Command{
+		Name:        args.Name,
+		Description: args.Description,
+		Args:        args.Args,
+	}
+	commands[args.Name] = c
+	return c
+}
+
+type Command struct {
+	Name        string
+	Description string
+	Args        []string
+}
+
+func (c Command) Execute() {
+}

Diff for: 2-cmd-setter-getter/.DS_Store

@@ -0,0 +1,47 @@
+package main
+
+var commands = map[string]Command{}
+
+func main() {
+	// create new command
+	command := cmd("get", "get todo by id", "id")
+	command.Execute()
+
+	// get the existing command
+	command = cmd("get")
+	command.Execute()
+}
+
+func cmd(args ...string) Command {
+	name, description, arguments := "", "", make([]string, 0)
+	if len(args) > 0 {
+		name = args[0]
+	}
+	c, ok := commands[name]
+	if ok {
+		return c
+	}
+
+	if len(args) > 1 {
+		description = args[1]
+	}
+	if len(args) > 2 {
+		arguments = args[2:]
+	}
+	c = Command{
+		Name:        name,
+		Description: description,
+		Args:        arguments,
+	}
+	commands[name] = c
+	return c
+}
+
+type Command struct {
+	Name        string
+	Description string
+	Args        []string
+}
+
+func (c Command) Execute() {
+}

Diff for: 2-cmd-setter-getter/main.go

@@ -0,0 +1,44 @@
+package main
+
+var commands = map[string]Command{}
+
+func main() {
+	// create new command
+	command := cmd("get", "get todo by id", "id")
+	command.Execute()
+
+	// get the existing command
+	command = cmd("get")
+	command.Execute()
+}
+
+func cmd(name string, args ...string) Command {
+	description, arguments := "", make([]string, 0)
+	c, ok := commands[name]
+	if ok {
+		return c
+	}
+
+	if len(args) > 1 {
+		description = args[1]
+	}
+	if len(args) > 2 {
+		arguments = args[2:]
+	}
+	c = Command{
+		Name:        name,
+		Description: description,
+		Args:        arguments,
+	}
+	commands[name] = c
+	return c
+}
+
+type Command struct {
+	Name        string
+	Description string
+	Args        []string
+}
+
+func (c Command) Execute() {
+}

Diff for: 3-cmd-variadic-struct-argument/main.go

@@ -1,2 +1,42 @@
-# variadic-functions
+# Variadic function in Go (Practical use cases)
+
 Variadic functions in Go (practical use cases)
+
+### Motivation
+
+- Accept an arbitrary number of arguments
+- Simulate optional arguments
+
+### Examples
+
+Here are some examples of variadic function in the Go standard library
+
+### Rules
+
+- variadic argument has to be the last one
+
+### Pros
+
+- Clean and elegant API
+
+### Cons
+
+- Generic and ambiguous arguments and argument names
+- No automatic conversion for `[]interface{}` aka `[]any`
+
+### Caveats
+
+Returning the passed slice
+You can’t use a variadic param as a result type, but, you can return it as a slice.
+
+func f(nums ...int) []int {
+nums[1] = 10
+return nums
+}
+
+### Resources
+
+- [Appending and copying slices - Go Spec](https://go.dev/ref/spec#Appending_and_copying_slices)
+- [Passing arguments to variadic functions - Go Spec](https://go.dev/ref/spec#Passing_arguments_to_..._parameters)
+- [Types Assignability - Go Spec](https://go.dev/ref/spec#Assignability)
+- [Types Identity - Go Spec](https://go.dev/ref/spec#Type_identity)

Diff for: 4-cmd-variadic-all-optional/.DS_Store

@@ -0,0 +1,18 @@
+package main
+
+func main() {
+	f(slice)
+	// cannot use this because:
+	// []T is different from ...T
+	// f(variadic)
+}
+
+func f(cb func([]int)) {
+	cb([]int{1, 2, 3})
+}
+
+func slice([]int) {
+}
+
+func variadic(...int) {
+}

Diff for: 4-cmd-variadic-all-optional/main.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+func main() {
+	intNumbers := []int{1, 2, 3}
+	anyNumbers := []any{1, 2, 3}
+	fmt.Println(1, 2, 3)
+	fmt.Println(anyNumbers...)
+	// does not work because slice types do not match
+	// the ...intNumbers will attempt to convert it to []interface{} and will fail
+	// fmt.Println(intNumbers...)
+
+	// converting each element of the intNumbers slice to any (interface{})
+	// will make sure the unpacked resulting slice's type is of the same type
+	var iNumbers = make([]any, len(intNumbers))
+	for i, num := range intNumbers {
+		iNumbers[i] = num
+	}
+	fmt.Println(iNumbers...)
+}

Diff for: 5-cmd-variadic-mandatory-args/.DS_Store

@@ -0,0 +1,7 @@
+package main
+
+func variadic1(int, string, ...string) {
+}
+
+// func variadic2(int, string, ...string, string) {
+// }

Diff for: 5-cmd-variadic-mandatory-args/main.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+	numbers := []int{1, 2, 3, 4, 5}
+	fmt.Println(numbers)
+
+	variadic(numbers...)
+	fmt.Println(numbers)
+}
+
+func variadic(args ...int) {
+	for i := 0; i < len(args); i++ {
+		args[i] = (i + 1) * 10
+	}
+}

Diff for: README.md

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+	variadic("1")
+	variadic("2", []int{}...)
+	variadic("3", []int(nil)...)
+	variadic("4", nil...)
+}
+
+func variadic(label string, nums ...int) {
+	if nums == nil {
+		fmt.Println(label, "nil")
+	}
+	// will always result in at least
+	// an empty slice (not a nil slice)
+	fmt.Println(nums)
+}