How to create custom methods for a package in Go…

In Go, you cannot "add" methods to existing packages or types that are declared outside of your package. Methods must always be declared in the same package as the type they belong to.

To create your own methods, you need to define your own type (struct, alias of an existing type, etc.) in your package, and then declare methods with this type as the receiver.

Example:

package mypackage

import "fmt"

// MyType - user-defined type
type MyType struct {
	Value string
}

// NewMyType - constructor function (not mandatory, but good practice)
func NewMyType(value string) *MyType {
	return &MyType{Value: value}
}

// MyMethod - method for MyType
func (m *MyType) MyMethod() {
	fmt.Printf("Executing MyMethod on object with value: %s\n", m.Value)
}

// AnotherMethod - another method
func (m MyType) AnotherMethod(prefix string) string {
	return prefix + m.Value
}

Usage in another package:

package main

import (
	"fmt"
	"mypackage" // Import our package
)

func main() {
	// Create an instance of our type
	obj := mypackage.NewMyType("Hello Go")

	// Call methods
	obj.MyMethod()

	result := obj.AnotherMethod("Prefixed: ")
	fmt.Println(result)
}

Key points:

Methods are declared with a receiver (the variable before the method name). The receiver is a variable representing the instance of the type on which the method is called.
The receiver can be a value ((m MyType)) or a pointer ((m *MyType)). The choice depends on whether the method needs to modify the object's state (in which case a pointer receiver is needed) and performance considerations (pointers may be preferable for large structs).
Methods should be declared at the top level of the package, not inside functions.
You cannot add a method to a type defined in another package (e.g., string or int). If you want to add behavior to an existing type, you can define a new type based on the existing one (alias or built-in type) and add methods to it, but this does not add methods to the original type.

Example with a type alias:

package myutils

import "strings"

// MyString - alias for string
type MyString string

// ToUpper - method for user-defined type MyString
func (s MyString) ToUpper() string {
	return strings.ToUpper(string(s)) // Convert MyString back to string
}

Usage:

package main

import (
	"fmt"
	"myutils"
)

func main() {
	ms := myutils.MyString("hello world")
	fmt.Println(ms.ToUpper()) // HELLO WORLD
}

How to create custom methods for a package in Go?