Dot Import

A dot import in Go is a package import declaration prefixed with a period (.). It instructs the compiler to inject all exported identifiers from the imported package directly into the importing file’s lexical file block scope. This allows the developer to reference the imported package’s functions, types, variables, and constants directly, bypassing the standard package qualifier.

package main

// Standard import
import "fmt"

// Dot import
import . "math"

func main() {
    // Requires the "fmt." package qualifier
    fmt.Println("Calculating...")

    // Bypasses the "math." package qualifier for functions and constants
    result := Sqrt(Pi) 
    
    fmt.Println(result)
}

Idiomatic Usage and Restrictions

In accordance with Go’s official Code Review Comments, dot imports are strongly discouraged in standard production code. Bypassing the package qualifier obscures the origin of identifiers, significantly harming code readability and maintainability.

The use of dot imports should be almost exclusively restricted to test files (_test.go). In testing contexts, they are permitted primarily to resolve circular dependencies or to facilitate black-box testing without the visual noise of repetitive package qualifiers. Teaching or using this feature outside of testing environments encourages an anti-pattern.

Lexical Scoping Rules

When utilizing a dot import, the Go compiler enforces specific scoping and resolution mechanics:

1. File Block Scope: The exported identifiers are injected into the file block of the specific .go file containing the import declaration. They are not injected into the broader package block. Other files within the same package must declare their own dot imports to achieve the same unqualified access.
2. Exported Identifiers Only: The dot import strictly applies to exported identifiers (those beginning with a capital letter). Unexported identifiers from the target package remain inaccessible, adhering to standard Go visibility rules.
3. Namespace Collisions: Because the identifiers are brought into the local file scope, they share the namespace with locally declared package-level identifiers. If a dot-imported identifier shares the exact name of a variable, constant, type, or function declared in the importing package, the compiler will yield a redeclaration error.

Syntax Variations

The dot import can be used in both single and factored import declarations:

// Single declaration
import . "strings"

// Factored declaration
import (
    "fmt"
    . "time"
    "os"
)

Master Go with Deep Grasping Methodology!

Learn More