Go Generic Functions 🎯

Welcome to our deep dive into Go Generic Functions! In this lesson, we'll explore the powerful world of generic functions in Go, a programming language known for its simplicity and efficiency. By the end of this tutorial, you'll have a solid understanding of generic functions, their benefits, and how to create your own. Let's get started!

What are Generic Functions? 📝

In Go, generic functions, also known as type parameters, are functions that can work with multiple data types without having to write multiple versions of the same function for each type. This saves time and improves code reusability.

// A simple function that adds two numbers
func add(x, y int) int {
    return x + y
}

In the example above, the add function works only with int types. However, with generic functions, we can create a single function that can work with various data types.

Creating a Generic Function 💡

Go does not support true generic functions like some other programming languages, such as C# or Java. Instead, Go uses interfaces to achieve a similar effect. Here's an example of a simple generic function in Go:

// The Addable interface defines the add method
type Addable interface {
    Add(x Addable) Addable
}

// Simple struct that implements the Addable interface
type Number struct {
    Value int
}

// The add method for the Number struct
func (n *Number) Add(other Addable) Addable {
    otherNumber, ok := other.(*Number)
    if !ok {
        panic("Type mismatch")
    }
    return &Number{Value: n.Value + otherNumber.Value}
}

// Creating two Number instances and adding them
n1 := &Number{Value: 5}
n2 := &Number{Value: 3}
result := n1.Add(n2)

In this example, we've created a Number struct that implements the Addable interface. The Addable interface defines a single method, Add, which takes another Addable as an argument. This allows us to create a generic add function that works for various data types that implement the Addable interface.

Quick Quiz

Question 1 of 1

What does the `Addable` interface define in our Go generic function example?

Using Generic Functions with Lists 💡

Let's take our generic functions to the next level by working with lists of various types. We'll create a List struct and a Concat function that concatenates two lists of the same type.

// The List struct and its methods
type List struct {
    values []interface{}
}

// The Append method adds an element to the list
func (list *List) Append(value interface{}) *List {
    list.values = append(list.values, value)
    return list
}

// The Concat function concatenates two lists of the same type
func Concat(list1, list2 List) List {
    for _, v := range list2.values {
        list1.Append(v)
    }
    return list1
}

// Creating two lists and concatenating them
list1 := &List{}
list2 := &List{[]interface{}{1, 2, 3}}
result := Concat(*list1, *list2)

In this example, we've created a List struct and the Concat function that works with any data type that implements the Addable interface. This means we can create lists of numbers, strings, or other custom types and concatenate them using our generic Concat function.

Quick Quiz

Question 1 of 1

What does the `Concat` function do in our Go generic function example?

Wrapping Up ✅

In this comprehensive lesson, we've explored Go generic functions and seen how they can improve code reusability and simplify working with various data types. We've created a Addable interface, a Number struct, and a List struct to demonstrate the power of generic functions in Go.

Remember to use simple language and clear explanations when working with generic functions, and be patient as you learn this powerful concept. Happy coding! 🤖