remove builtin component

container/tree/tree.go

@@ -109,14 +109,14 @@ var defaultOptions = &Options{
 
 // Fix ensures all options have valid values, using defaults where necessary.
 func (options *Options) Fix() {
-	options.Parent = operator.Or(options.Parent, defaultOptions.Parent)
+	operator.SetDefault(&options.Parent, defaultOptions.Parent)
 	if options.Branch == "" {
 		options.Branch = defaultOptions.Branch
-		options.LastBranch = operator.Or(options.LastBranch, defaultOptions.LastBranch)
+		operator.SetDefault(&options.LastBranch, defaultOptions.LastBranch)
 	} else if options.LastBranch == "" {
 		options.LastBranch = options.Branch
 	}
-	options.Space = operator.Or(options.Space, defaultOptions.Space)
+	operator.SetDefault(&options.Space, defaultOptions.Space)
 }
 
 // Stringify converts a node to a string representation.

operator/operator.go

@@ -5,16 +5,6 @@ package operator
 
 import "github.com/gopherd/core/constraints"
 
-// Or returns b if a is the zero value for T, otherwise returns a.
-// It provides a generic "or" operation for any comparable type.
-func Or[T comparable](a, b T) T {
-	var zero T
-	if a == zero {
-		return b
-	}
-	return a
-}
-
 // OrFunc returns the result of calling b() if a is the zero value for T,
 // otherwise returns a. It allows for lazy evaluation of the alternative value.
 func OrFunc[T comparable](a T, b func() T) T {

operator/operator_test.go

@@ -7,35 +7,6 @@ import (
 	"github.com/gopherd/core/operator"
 )
 
-func TestOr(t *testing.T) {
-	tests := []struct {
-		name       string
-		a, b, want int
-	}{
-		{"both non-zero", 1, 2, 1},
-		{"a zero", 0, 2, 2},
-		{"b zero", 1, 0, 1},
-		{"both zero", 0, 0, 0},
-		{"negative values", -1, -2, -1},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := operator.Or(tt.a, tt.b); got != tt.want {
-				t.Errorf("Or(%v, %v) = %v, want %v", tt.a, tt.b, got, tt.want)
-			}
-		})
-	}
-
-	// Test with string type
-	if got := operator.Or("", "default"); got != "default" {
-		t.Errorf(`Or("", "default") = %q, want "default"`, got)
-	}
-	if got := operator.Or("value", "default"); got != "value" {
-		t.Errorf(`Or("value", "default") = %q, want "value"`, got)
-	}
-}
-
 func TestOrFunc(t *testing.T) {
 	counter := 0
 	newFunc := func() int {