Creating custom packages in Go - Visual Walkthrough

Concept Flow - Creating custom packages

Create folder for package

↓

Write Go files with package name

↓

Export functions/variables (capitalized)

↓

Import package in main program

↓

Use exported functions/variables

↓

Run or build program

This flow shows how to create a Go package by making a folder, writing code with a package name, exporting items, importing it elsewhere, and using it.

Execution Sample

Go

package mathutil

func Add(a, b int) int {
    return a + b
}

Defines a custom package 'mathutil' with an exported function Add that sums two integers.

Execution Table

Step	Action	Code Line	Effect	Output/State
1	Create folder 'mathutil'	N/A	Folder created for package	Folder 'mathutil' exists
2	Write package declaration	package mathutil	Defines package name	Package named 'mathutil'
3	Write exported function Add	func Add(a, b int) int { return a + b }	Function Add available outside package	Add function ready
4	In main.go, import package	import "mathutil"	Imports custom package	Package 'mathutil' imported
5	Call Add function	result := mathutil.Add(3, 4)	Calls Add with 3 and 4	result = 7
6	Print result	fmt.Println(result)	Outputs sum	7 printed
7	Program ends	N/A	Execution complete	Program exits

💡 Program ends after printing the sum 7

Variable Tracker

Variable	Start	After Step 5	Final
result	undefined	7	7

Key Moments - 3 Insights

Why must the function name start with a capital letter to be used outside the package?

In Go, only names starting with a capital letter are exported and visible outside their package, as shown in step 3 and 5 where Add is accessible.

What happens if the package is not imported correctly in main.go?

If the import is missing or wrong (step 4), the program cannot find the package and will fail to compile or run.

Why do we create a separate folder for the package?

Go organizes packages by folders; creating a folder (step 1) helps Go find and manage the package code.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'result' after step 5?

A undefined

B 3

C 7

D 0

💡 Hint

Check the 'Effect' and 'Output/State' columns in row for step 5.

At which step is the package 'mathutil' imported into the main program?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look for the 'Action' column mentioning import in the execution table.

If the function Add was named 'add' (lowercase), what would happen when calling it in main.go?

A The program would fail to compile because 'add' is not exported.

B It would work normally.

C The program would print 0.

D The program would run but return wrong results.

💡 Hint

Refer to the key moment about capitalized names being exported.

Concept Snapshot

Creating custom packages in Go:
- Create a folder with package files
- Use 'package name' at top of files
- Export functions by capitalizing names
- Import package in main with import
- Call exported functions with package.Func
- Run program to use your package

Full Transcript

This visual execution shows how to create a custom package in Go. First, you create a folder named for your package. Inside, write Go files starting with 'package yourpackagename'. Export functions by naming them with a capital letter, like Add. In your main program, import the package using import statement with the folder path. Then call the exported functions with package name prefix. The execution table traces creating the folder, writing code, importing, calling Add(3,4), and printing the result 7. Variables like 'result' hold the sum after calling Add. Key moments explain why capitalization matters for export, the need to import packages, and folder structure. The quiz tests understanding of variable values, import steps, and export rules. The snapshot summarizes the steps to create and use custom packages in Go.

Practice

1. What is the main purpose of creating a custom package in Go?

easy

A. To organize code into reusable parts

B. To make the program run faster

C. To avoid using functions

D. To write code without imports

Solution

1. Step 1: Understand the role of packages

   Packages help group related code together for reuse and clarity.

2. Step 2: Identify the main benefit

   Custom packages allow you to reuse code in different parts of your program or in other programs.

3. Final Answer:

   To organize code into reusable parts -> Option A

4. Quick Check:

   Custom packages = reusable code [OK]

Hint: Packages group code for reuse and clarity [OK]

Common Mistakes:

• Thinking packages speed up code execution
• Believing packages remove the need for functions
• Assuming packages eliminate imports

2. Which of the following is the correct way to export a function from a custom package in Go?

easy

A. func MyFunction() {}

B. func my_function() {}

C. func _MyFunction() {}

D. func myFunction() {}

Solution

1. Step 1: Recall Go export rules

   In Go, only names starting with an uppercase letter are exported (visible outside the package).

2. Step 2: Check function names

   Only 'MyFunction' starts with uppercase, so it is exported.

3. Final Answer:

   func MyFunction() {} -> Option A

4. Quick Check:

   Uppercase start = exported function [OK]

Hint: Exported names start with uppercase letters [OK]

Common Mistakes:

• Using lowercase to export functions
• Using underscores to export
• Assuming snake_case exports functions

3. Given a package named mathutil with an exported function Square, what is the output of this code?

package main

import (
  "fmt"
  "mathutil"
)

func main() {
  fmt.Println(mathutil.Square(4))
}

medium

A. Square(4)

B. 16

C. Error: undefined mathutil

D. 0

Solution

1. Step 1: Understand the function call

   The code calls mathutil.Square(4), which should return 4 squared (4*4).

2. Step 2: Calculate the expected output

   4 multiplied by 4 equals 16, so the output is 16.

3. Final Answer:

   16 -> Option B

4. Quick Check:

   Square(4) = 16 [OK]

Hint: Square means multiply number by itself [OK]

Common Mistakes:

• Assuming function name prints as string
• Thinking import fails without path
• Expecting zero as default output

4. What is wrong with this custom package usage?

package main

import (
  "fmt"
  "mypkg"
)

func main() {
  fmt.Println(mypkg.helper())
}

Assuming helper is a function in mypkg.

medium

A. Package name must be Main to import

B. fmt.Println cannot print function results

C. Import path must be a URL

D. Function name should start with uppercase to be accessible

Solution

1. Step 1: Check function visibility rules

   In Go, only functions starting with uppercase letters are exported and accessible outside their package.

2. Step 2: Identify the function name issue

   The function is named 'helper' (lowercase), so it is not accessible from main package.

3. Final Answer:

   Function name should start with uppercase to be accessible -> Option D

4. Quick Check:

   Lowercase function = not exported [OK]

Hint: Exported functions start uppercase [OK]

Common Mistakes:

• Thinking package name must be Main
• Believing import path must be URL
• Assuming fmt.Println can't print function output

5. You want to create a custom package stringutil with a function Reverse that reverses a string. Which of the following is the correct way to define and use it in your main.go?

hard

A. In stringutil package: func Reverse(s string) string { /* code */ }In main.go: import "stringutil" and call Reverse("hello")

B. In stringutil package: func reverse(s string) string { /* code */ }In main.go: import "stringutil" and call stringutil.reverse("hello")

C. In stringutil package: func Reverse(s string) string { /* code */ }In main.go: import "stringutil" and call stringutil.Reverse("hello")

D. In stringutil package: func Reverse(s string) string { /* code */ }In main.go: no import needed, call Reverse("hello")

Solution

1. Step 1: Define exported function in package

   The function must start with uppercase 'Reverse' to be accessible outside the package.

2. Step 2: Import package and call function with package name

   In main.go, import "stringutil" and call the function as stringutil.Reverse("hello").

3. Final Answer:

   Define func Reverse and call stringutil.Reverse("hello") after import -> Option C

4. Quick Check:

   Uppercase function + import + package prefix = correct usage [OK]

Hint: Exported func uppercase + import + package.func call [OK]

Common Mistakes:

• Using lowercase function name and expecting export
• Calling function without package prefix after import
• Not importing the custom package