option

func (Option[T]) Expect ¶

func (optn Option[T]) Expect(panicMsg string) T

Expect returns the contained value or panics with your custom message. Use ONLY when you are absolutely certain a value exists (e.g., in tests or after IsSome check).

When to use:

• In unit tests where absence indicates a test failure
• After validation where absence is a programming error
• When the absence represents an unrecoverable invariant violation

AVOID in production code paths where absence is a valid business case.

Example - Test assertion where value must exist:

func TestUserCreation(t *testing.T) {
    userOpt := CreateUser("test@example.com")
    user := userOpt.Expect("user creation should never fail in test setup")
    assert.Equal(t, "test@example.com", user.Email)
}

Example - After validation in critical initialization:

func InitializeApp() {
    dbOpt := LoadDatabaseConfig()
    if dbOpt.IsNone() {
        log.Fatal("database configuration is required")
    }
    db := dbOpt.Expect("database config validated but still None - programming error")
}

func (Option[T]) IsNone ¶

func (optn Option[T]) IsNone() bool

IsNone reports whether the Option is empty (contains no value). Equivalent to !IsSome() but reads more naturally in some contexts.

When to use:

• When checking for absence is more natural than checking for presence
• When early-returning on missing values
• When validating that operations produced no result

Example - Early return pattern for missing configuration:

func ProcessConfig(configOpt Option[Config]) error {
    if configOpt.IsNone() {
        return fmt.Errorf("configuration not provided")
    }
    config := configOpt.Unwrap()
    // Continue processing with config...
    return nil
}

func (Option[T]) IsSome ¶

func (optn Option[T]) IsSome() bool

IsSome reports whether the Option contains a value. Use this for explicit checking before accessing the value.

When to use:

• When you need to branch on presence/absence in if statements
• When you want to validate before unwrapping
• When logging or debugging optional states

Example - Conditional processing based on value presence:

userOpt := FindUserByEmail("user@example.com")
if userOpt.IsSome() {
    user := userOpt.Unwrap()
    log.Printf("Found user: %s", user.Name)
    SendWelcomeEmail(user.Email)
} else {
    log.Println("User not found, creating new account")
    CreateNewUser("user@example.com")
}

func (Option[T]) Some ¶

func (optn Option[T]) Some(out *T) bool

Some copies the value into the provided pointer if present, returning true if successful. This is Go's idiomatic way to extract an optional value (similar to map access pattern).

When to use:

• When you want Go-style "comma ok" idiom for optional values
• When you need to extract into an existing variable
• When integrating with code that expects the "value, ok" pattern

Example - Go-idiomatic optional extraction:

var user User
if userOpt.Some(&user) {
    log.Printf("Processing user: %s", user.Name)
    ProcessUser(user)
} else {
    log.Println("No user found, skipping processing")
}

Example - Multiple optional extractions:

var config Config
var port int
if configOpt.Some(&config) && config.Port.Some(&port) {
    server.Start(port)
}

func (Option[T]) Unwrap ¶

func (optn Option[T]) Unwrap() T

Unwrap returns the contained value or panics with a generic message. Shorthand for Expect with a default panic message.

When to use:

• In tests where you want quick assertions
• When prototyping and you'll add proper handling later

PREFER UnwrapOr or UnwrapOrElse in production code.

Example - Quick test validation:

func TestFindUser(t *testing.T) {
    userOpt := repo.FindByID(123)
    user := userOpt.Unwrap() // Panics if not found - acceptable in tests
    assert.Equal(t, "John Doe", user.Name)
}

func (Option[T]) UnwrapOr ¶

func (optn Option[T]) UnwrapOr(defaultValue T) T

UnwrapOr returns the contained value if present, otherwise returns the provided default. This is the SAFE way to extract values with a fallback.

When to use:

• When you have a reasonable default value
• When absence is normal and you want to continue with a fallback
• When you want to avoid if-else branching

Example - Configuration with defaults:

func GetServerPort() int {
    portOpt := LoadPortFromConfig()
    return portOpt.UnwrapOr(8080) // Default to 8080 if not configured
}

Example - User preferences with fallback:

func GetUserTheme(userID int) string {
    themeOpt := FetchUserTheme(userID)
    return themeOpt.UnwrapOr("light") // Default theme if user hasn't set one
}

func (Option[T]) UnwrapOrElse ¶

func (optn Option[T]) UnwrapOrElse(fn func() T) T

UnwrapOrElse returns the value if present, otherwise computes a fallback using the provided function. Use when the fallback is expensive to compute or requires dynamic calculation.

When to use:

• When the default value is expensive to create (database call, API request)
• When the fallback requires computation that shouldn't run unless needed
• When the fallback depends on runtime conditions

Example - Expensive fallback (database query):

func GetCachedOrFetchUser(userID int) User {
    cachedOpt := GetFromCache(userID)
    return cachedOpt.UnwrapOrElse(func() User {
        // This database query only runs if cache misses
        user, _ := FetchUserFromDB(userID)
        return user
    })
}

Example - Dynamic fallback (current timestamp):

func GetLastLoginTime(userID int) time.Time {
    loginOpt := FetchLastLogin(userID)
    return loginOpt.UnwrapOrElse(func() time.Time {
        return time.Now() // Generate current time only if no last login exists
    })
}