Go Module Management: Building a Reusable Package

This challenge focuses on the fundamental Go concept of package management and importing. You will learn how to create your own reusable Go package and then import and utilize it within another Go program. This is a crucial skill for building larger, modular, and maintainable Go applications.

Problem Description

Your task is to create a simple Go package that performs a common operation, and then write a separate Go program that imports and uses this package.

Specifically, you need to:

1. Create a Go Module: Initialize a new Go module for your custom package.
2. Develop a Reusable Function: Inside this module, create a function that performs a useful task (e.g., a mathematical operation, string manipulation, or data validation). This function should be exported (i.e., start with a capital letter).
3. Create a Main Program: In a separate directory, create a Go program that imports your custom module.
4. Utilize the Imported Function: Call the exported function from your custom package within the main program and print the result.

Key Requirements:

• Your custom package should reside in its own distinct Go module.
• The function you create must be accessible from outside its own package.
• The main program must correctly import your custom module using its module path.
• The output of the main program should clearly demonstrate that the imported function was called and its result is being displayed.

Expected Behavior:

When the main program is run, it should successfully compile and execute, printing the output generated by the imported function from your custom package.

Edge Cases to Consider:

• What happens if the module path is mistyped during import? (Your Go environment should handle this with a compile-time error, which is the expected behavior.)
• Ensure your exported function handles its inputs gracefully.

Examples

Example 1: Simple Calculator Package

Custom Package (e.g., github.com/yourusername/calculator)

// calculator/add.go
package calculator

// Add takes two integers and returns their sum.
func Add(a, b int) int {
	return a + b
}

Main Program (e.g., in a separate myapp directory)

// myapp/main.go
package main

import (
	"fmt"
	"github.com/yourusername/calculator" // Assuming your module path is this
)

func main() {
	num1 := 10
	num2 := 5
	sum := calculator.Add(num1, num2)
	fmt.Printf("The sum of %d and %d is: %d\n", num1, num2, sum)
}

Input (for running go run myapp/main.go after setting up modules):

No direct input is provided in the main.go file for this example; the values are hardcoded.

Output:

The sum of 10 and 5 is: 15

Explanation:

The main package imports the calculator package. It then calls the Add function from calculator, passing 10 and 5 as arguments. The returned sum, 15, is then printed.

Example 2: String Utility Package

Custom Package (e.g., github.com/yourusername/strutil)

// strutil/reverse.go
package strutil

import "strings"

// ReverseString takes a string and returns its reversed version.
func ReverseString(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

Main Program (e.g., in a separate myapp directory)

// myapp/main.go
package main

import (
	"fmt"
	"github.com/yourusername/strutil" // Assuming your module path is this
)

func main() {
	original := "Hello Go!"
	reversed := strutil.ReverseString(original)
	fmt.Printf("Original: %s\n", original)
	fmt.Printf("Reversed: %s\n", reversed)
}

Input (for running go run myapp/main.go after setting up modules):

No direct input is provided in the main.go file for this example; the string is hardcoded.

Output:

Original: Hello Go!
Reversed: !oG olleH

Explanation:

The main package imports the strutil package. It then calls ReverseString with "Hello Go!". The returned reversed string is printed along with the original.

Constraints

• Your custom package and main program should be written in Go.
• You must use Go modules for dependency management.
• The custom package should contain at least one exported function.
• The main program should successfully compile and run without errors.
• The output should be clearly understandable and reflect the function call.

Notes

• To create a Go module, navigate to your custom package's directory and run go mod init <module_path>, where <module_path> is typically your repository path (e.g., github.com/yourusername/calculator).
• In your main program, use go get <module_path> to fetch your local module if it's not automatically recognized. Alternatively, you can use go mod tidy in the main program's directory after importing the package.
• Think about what kind of simple, reusable functionality would be interesting to implement.
• The module_path you choose during go mod init is critical for how you will import your package in other programs.