refactor: type Result change initialize behavior

initdc · initdc · commit a88db486675e · 2025-12-01T18:53:45.000+08:00
diff --git a/result/result.go b/result/result.go
@@ -11,16 +11,16 @@ type Result[T, E any] struct {
 	assigned bool
 }
 
-func Ok[T, E any](v T) Result[T, E] {
-	return Result[T, E]{
+func Ok[T, E any](v T) *Result[T, E] {
+	return &Result[T, E]{
 		value:    v,
 		ok:       true,
 		assigned: true,
 	}
 }
 
-func Err[T, E any](e E) Result[T, E] {
-	return Result[T, E]{
+func Err[T, E any](e E) *Result[T, E] {
+	return &Result[T, E]{
 		err:      e,
 		ok:       false,
 		assigned: true,
@@ -57,7 +57,7 @@ func (r Result[T, E]) IsOk() bool {
 	return r.ok
 }
 
-func (r Result[T, E]) IsOkAnd(f func(T) bool) bool {
+func (r *Result[T, E]) IsOkAnd(f func(T) bool) bool {
 	if !r.ok {
 		return false
 	}
@@ -68,144 +68,145 @@ func (r Result[T, E]) IsErr() bool {
 	return !r.ok
 }
 
-func (r Result[T, E]) IsErrAnd(f func(E) bool) bool {
+func (r *Result[T, E]) IsErrAnd(f func(E) bool) bool {
 	if r.ok {
 		return false
 	}
 	return f(r.err)
 }
 
-func Map[T, E, U any](r Result[T, E], f func(T) U) Result[U, E] {
+func Map[T, E, U any](r *Result[T, E], f func(T) U) *Result[U, E] {
 	if r.ok {
 		return Ok[U, E](f(r.value))
 	}
 	return Err[U, E](r.err)
 }
 
-func MapOr[T, E, U any](r Result[T, E], def U, f func(T) U) U {
+func MapOr[T, E, U any](r *Result[T, E], def U, f func(T) U) U {
 	if r.ok {
 		return f(r.value)
 	}
 	return def
 }
 
-func MapOrElse[T, E, U any](r Result[T, E], def func(E) U, f func(T) U) U {
+func MapOrElse[T, E, U any](r *Result[T, E], def func(E) U, f func(T) U) U {
 	if r.ok {
 		return f(r.value)
 	}
 	return def(r.err)
 }
 
-func MapOrDefault[T, E, U any](r Result[T, E], f func(T) U) U {
+func MapOrDefault[T, E, U any](r *Result[T, E], f func(T) U) U {
 	if r.ok {
 		return f(r.value)
 	}
 	var zero U
 	return zero
 }
 
-func MapErr[T, E, F any](r Result[T, E], f func(E) F) Result[T, F] {
+func MapErr[T, E, F any](r *Result[T, E], f func(E) F) *Result[T, F] {
 	if r.ok {
 		return Ok[T, F](r.value)
 	}
 	return Err[T, F](f(r.err))
 }
 
-func (r Result[T, E]) Inspect(f func(T)) Result[T, E] {
+func (r *Result[T, E]) Inspect(f func(T)) *Result[T, E] {
 	if r.ok {
 		f(r.value)
 	}
 	return r
 }
 
-func (r Result[T, E]) InspectErr(f func(E)) Result[T, E] {
+func (r *Result[T, E]) InspectErr(f func(E)) *Result[T, E] {
 	if !r.ok {
 		f(r.err)
 	}
 	return r
 }
 
-func (r Result[T, E]) Expect(msg string) T {
+func (r *Result[T, E]) Expect(msg string) T {
 	if r.ok {
 		return r.value
 	}
 	panic(fmt.Sprintf("%s: %v", msg, r.err))
 }
 
-func (r Result[T, E]) Unwrap() T {
+func (r *Result[T, E]) Unwrap() T {
 	if r.ok {
 		return r.value
 	}
 	panic(fmt.Sprintf("called Result.Unwrap() on an Err value: %v", r.err))
 }
 
-func (r Result[T, E]) UnwrapOrDefault() T {
+func (r *Result[T, E]) UnwrapOrDefault() T {
 	if r.ok {
 		return r.value
 	}
 	var zero T
 	return zero
 }
 
-func (r Result[T, E]) ExpectErr(msg string) E {
+func (r *Result[T, E]) ExpectErr(msg string) E {
 	if r.ok {
 		panic(fmt.Sprintf("%s: %v", msg, r.value))
 	}
 	return r.err
 }
 
-func (r Result[T, E]) UnwrapErr() E {
+func (r *Result[T, E]) UnwrapErr() E {
 	if r.ok {
 		panic(fmt.Sprintf("called Result.UnwrapErr() on an Ok value: %v", r.value))
 	}
 	return r.err
 }
 
-func And[T, E, U any](r Result[T, E], res Result[U, E]) Result[U, E] {
+func And[T, E, U any](r *Result[T, E], res *Result[U, E]) *Result[U, E] {
 	if r.ok {
 		return res
 	}
 	return Err[U, E](r.err)
 }
 
-func AndThen[T, E, U any](r Result[T, E], op func(T) Result[U, E]) Result[U, E] {
+func AndThen[T, E, U any](r *Result[T, E], op func(T) *Result[U, E]) *Result[U, E] {
 	if r.ok {
 		return op(r.value)
 	}
 	return Err[U, E](r.err)
 }
 
-func Or[T, E, F any](r Result[T, E], res Result[T, F]) Result[T, F] {
+func Or[T, E, F any](r *Result[T, E], res *Result[T, F]) *Result[T, F] {
 	if r.ok {
 		return Ok[T, F](r.value)
 	}
 	return res
 }
 
-func OrElse[T, E, F any](r Result[T, E], op func(E) Result[T, F]) Result[T, F] {
+func OrElse[T, E, F any](r *Result[T, E], op func(E) *Result[T, F]) *Result[T, F] {
 	if r.ok {
 		return Ok[T, F](r.value)
 	}
 	return op(r.err)
 }
 
-func Try[T, E, U, F any](r Result[T, E], op func(T) U, closure func(E) Result[U, F]) Result[U, F] {
+func Try[T, E, U, F any](r *Result[T, E], op func(T) U, closure func(E) *Result[U, F]) *Result[U, F] {
 	if r.ok {
 		return Ok[U, F](op(r.value))
 	}
 	closure(r.err)
 	// unreachable
+	fmt.Println("Result unreachable")
 	return closure(r.err)
 }
 
-func (r Result[T, E]) UnwrapOr(def T) T {
+func (r *Result[T, E]) UnwrapOr(def T) T {
 	if r.ok {
 		return r.value
 	}
 	return def
 }
 
-func (r Result[T, E]) UnwrapOrElse(f func(E) T) T {
+func (r *Result[T, E]) UnwrapOrElse(f func(E) T) T {
 	if r.ok {
 		return r.value
 	}
diff --git a/result/result_test.go b/result/result_test.go
@@ -22,8 +22,8 @@ func TestOk(t *testing.T) {
 	c := Ok[int, string](1)
 
 	assert.Equal(t, a, b)
-	assert.Equal(t, a, c)
-	assert.Equal(t, b, c)
+	assert.Equal(t, a, *c)
+	assert.Equal(t, b, *c)
 }
 
 func TestErr(t *testing.T) {
@@ -39,8 +39,8 @@ func TestErr(t *testing.T) {
 	c := Err[int, string]("error")
 
 	assert.Equal(t, a, b)
-	assert.Equal(t, a, c)
-	assert.Equal(t, b, c)
+	assert.Equal(t, a, *c)
+	assert.Equal(t, b, *c)
 }
 
 func TestIsOk(t *testing.T) {
@@ -173,7 +173,7 @@ func TestUnwrap(t *testing.T) {
 }
 
 func TestUnwrapOrDefault(t *testing.T) {
-	parseYear := func(s string) Result[int, string] {
+	parseYear := func(s string) *Result[int, string] {
 		year, err := strconv.Atoi(s)
 		if err != nil {
 			return Err[int, string]("parseYear failed")
@@ -218,7 +218,7 @@ func TestAnd(t *testing.T) {
 }
 
 func TestAndThen(t *testing.T) {
-	sqThenToString := func(x int) Result[string, string] {
+	sqThenToString := func(x int) *Result[string, string] {
 		if x > 100 || x < 0 {
 			return Err[string, string]("overflowed")
 		}
@@ -255,8 +255,8 @@ func TestOr(t *testing.T) {
 }
 
 func TestOrElse(t *testing.T) {
-	sq := func(x int) Result[int, int] { return Ok[int, int](x * x) }
-	err := func(x int) Result[int, int] { return Err[int, int](x) }
+	sq := func(x int) *Result[int, int] { return Ok[int, int](x * x) }
+	err := func(x int) *Result[int, int] { return Err[int, int](x) }
 
 	r := Ok[int, int](2)
 	e := Err[int, int](3)
@@ -269,7 +269,7 @@ func TestOrElse(t *testing.T) {
 
 func TestTry(t *testing.T) {
 	f1 := func(x int) float32 { return float32(x) * 2 }
-	closure := func(e rune) Result[float32, string] { return Err[float32, string](string(e)) }
+	closure := func(e rune) *Result[float32, string] { return Err[float32, string](string(e)) }
 
 	r := Ok[int, rune](1)
 	assert.Equal(t, Try(r, f1, closure), Ok[float32, string](2.0))
@@ -318,15 +318,15 @@ func TestResultWithComplexTypes(t *testing.T) {
 
 func TestChainedOperations(t *testing.T) {
 	// 测试链式操作
-	parse := func(s string) Result[int, string] {
+	parse := func(s string) *Result[int, string] {
 		i, err := strconv.Atoi(s)
 		if err != nil {
 			return Err[int, string]("invalid number")
 		}
 		return Ok[int, string](i)
 	}
 
-	double := func(x int) Result[int, string] {
+	double := func(x int) *Result[int, string] {
 		if x > 100 {
 			return Err[int, string]("too large")
 		}

Original file line number	Diff line number	Diff line change
`@@ -11,16 +11,16 @@ type Result[T, E any] struct {`
`11`	`11`	`assigned bool`
`12`	`12`	`}`
`13`	`13`
`14`		`-func Ok[T, E any](v T) Result[T, E] {`
`15`		`- return Result[T, E]{`
	`14`	`+func Ok[T, E any](v T) *Result[T, E] {`
	`15`	`+ return &Result[T, E]{`
`16`	`16`	`value: v,`
`17`	`17`	`ok: true,`
`18`	`18`	`assigned: true,`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`		`-func Err[T, E any](e E) Result[T, E] {`
`23`		`- return Result[T, E]{`
	`22`	`+func Err[T, E any](e E) *Result[T, E] {`
	`23`	`+ return &Result[T, E]{`
`24`	`24`	`err: e,`
`25`	`25`	`ok: false,`
`26`	`26`	`assigned: true,`
`@@ -57,7 +57,7 @@ func (r Result[T, E]) IsOk() bool {`
`57`	`57`	`return r.ok`
`58`	`58`	`}`
`59`	`59`
`60`		`-func (r Result[T, E]) IsOkAnd(f func(T) bool) bool {`
	`60`	`+func (r *Result[T, E]) IsOkAnd(f func(T) bool) bool {`
`61`	`61`	`if !r.ok {`
`62`	`62`	`return false`
`63`	`63`	`}`
`@@ -68,144 +68,145 @@ func (r Result[T, E]) IsErr() bool {`
`68`	`68`	`return !r.ok`
`69`	`69`	`}`
`70`	`70`
`71`		`-func (r Result[T, E]) IsErrAnd(f func(E) bool) bool {`
	`71`	`+func (r *Result[T, E]) IsErrAnd(f func(E) bool) bool {`
`72`	`72`	`if r.ok {`
`73`	`73`	`return false`
`74`	`74`	`}`
`75`	`75`	`return f(r.err)`
`76`	`76`	`}`
`77`	`77`
`78`		`-func Map[T, E, U any](r Result[T, E], f func(T) U) Result[U, E] {`
	`78`	`+func Map[T, E, U any](r Result[T, E], f func(T) U) Result[U, E] {`
`79`	`79`	`if r.ok {`
`80`	`80`	`return Ok[U, E](f(r.value))`
`81`	`81`	`}`
`82`	`82`	`return Err[U, E](r.err)`
`83`	`83`	`}`
`84`	`84`
`85`		`-func MapOr[T, E, U any](r Result[T, E], def U, f func(T) U) U {`
	`85`	`+func MapOr[T, E, U any](r *Result[T, E], def U, f func(T) U) U {`
`86`	`86`	`if r.ok {`
`87`	`87`	`return f(r.value)`
`88`	`88`	`}`
`89`	`89`	`return def`
`90`	`90`	`}`
`91`	`91`
`92`		`-func MapOrElse[T, E, U any](r Result[T, E], def func(E) U, f func(T) U) U {`
	`92`	`+func MapOrElse[T, E, U any](r *Result[T, E], def func(E) U, f func(T) U) U {`
`93`	`93`	`if r.ok {`
`94`	`94`	`return f(r.value)`
`95`	`95`	`}`
`96`	`96`	`return def(r.err)`
`97`	`97`	`}`
`98`	`98`
`99`		`-func MapOrDefault[T, E, U any](r Result[T, E], f func(T) U) U {`
	`99`	`+func MapOrDefault[T, E, U any](r *Result[T, E], f func(T) U) U {`
`100`	`100`	`if r.ok {`
`101`	`101`	`return f(r.value)`
`102`	`102`	`}`
`103`	`103`	`var zero U`
`104`	`104`	`return zero`
`105`	`105`	`}`
`106`	`106`
`107`		`-func MapErr[T, E, F any](r Result[T, E], f func(E) F) Result[T, F] {`
	`107`	`+func MapErr[T, E, F any](r Result[T, E], f func(E) F) Result[T, F] {`
`108`	`108`	`if r.ok {`
`109`	`109`	`return Ok[T, F](r.value)`
`110`	`110`	`}`
`111`	`111`	`return Err[T, F](f(r.err))`
`112`	`112`	`}`
`113`	`113`
`114`		`-func (r Result[T, E]) Inspect(f func(T)) Result[T, E] {`
	`114`	`+func (r Result[T, E]) Inspect(f func(T)) Result[T, E] {`
`115`	`115`	`if r.ok {`
`116`	`116`	`f(r.value)`
`117`	`117`	`}`
`118`	`118`	`return r`
`119`	`119`	`}`
`120`	`120`
`121`		`-func (r Result[T, E]) InspectErr(f func(E)) Result[T, E] {`
	`121`	`+func (r Result[T, E]) InspectErr(f func(E)) Result[T, E] {`
`122`	`122`	`if !r.ok {`
`123`	`123`	`f(r.err)`
`124`	`124`	`}`
`125`	`125`	`return r`
`126`	`126`	`}`
`127`	`127`
`128`		`-func (r Result[T, E]) Expect(msg string) T {`
	`128`	`+func (r *Result[T, E]) Expect(msg string) T {`
`129`	`129`	`if r.ok {`
`130`	`130`	`return r.value`
`131`	`131`	`}`
`132`	`132`	`panic(fmt.Sprintf("%s: %v", msg, r.err))`
`133`	`133`	`}`
`134`	`134`
`135`		`-func (r Result[T, E]) Unwrap() T {`
	`135`	`+func (r *Result[T, E]) Unwrap() T {`
`136`	`136`	`if r.ok {`
`137`	`137`	`return r.value`
`138`	`138`	`}`
`139`	`139`	`panic(fmt.Sprintf("called Result.Unwrap() on an Err value: %v", r.err))`
`140`	`140`	`}`
`141`	`141`
`142`		`-func (r Result[T, E]) UnwrapOrDefault() T {`
	`142`	`+func (r *Result[T, E]) UnwrapOrDefault() T {`
`143`	`143`	`if r.ok {`
`144`	`144`	`return r.value`
`145`	`145`	`}`
`146`	`146`	`var zero T`
`147`	`147`	`return zero`
`148`	`148`	`}`
`149`	`149`
`150`		`-func (r Result[T, E]) ExpectErr(msg string) E {`
	`150`	`+func (r *Result[T, E]) ExpectErr(msg string) E {`
`151`	`151`	`if r.ok {`
`152`	`152`	`panic(fmt.Sprintf("%s: %v", msg, r.value))`
`153`	`153`	`}`
`154`	`154`	`return r.err`
`155`	`155`	`}`
`156`	`156`
`157`		`-func (r Result[T, E]) UnwrapErr() E {`
	`157`	`+func (r *Result[T, E]) UnwrapErr() E {`
`158`	`158`	`if r.ok {`
`159`	`159`	`panic(fmt.Sprintf("called Result.UnwrapErr() on an Ok value: %v", r.value))`
`160`	`160`	`}`
`161`	`161`	`return r.err`
`162`	`162`	`}`
`163`	`163`
`164`		`-func And[T, E, U any](r Result[T, E], res Result[U, E]) Result[U, E] {`
	`164`	`+func And[T, E, U any](r Result[T, E], res Result[U, E]) *Result[U, E] {`
`165`	`165`	`if r.ok {`
`166`	`166`	`return res`
`167`	`167`	`}`
`168`	`168`	`return Err[U, E](r.err)`
`169`	`169`	`}`
`170`	`170`
`171`		`-func AndThen[T, E, U any](r Result[T, E], op func(T) Result[U, E]) Result[U, E] {`
	`171`	`+func AndThen[T, E, U any](r Result[T, E], op func(T) Result[U, E]) *Result[U, E] {`
`172`	`172`	`if r.ok {`
`173`	`173`	`return op(r.value)`
`174`	`174`	`}`
`175`	`175`	`return Err[U, E](r.err)`
`176`	`176`	`}`
`177`	`177`
`178`		`-func Or[T, E, F any](r Result[T, E], res Result[T, F]) Result[T, F] {`
	`178`	`+func Or[T, E, F any](r Result[T, E], res Result[T, F]) *Result[T, F] {`
`179`	`179`	`if r.ok {`
`180`	`180`	`return Ok[T, F](r.value)`
`181`	`181`	`}`
`182`	`182`	`return res`
`183`	`183`	`}`
`184`	`184`
`185`		`-func OrElse[T, E, F any](r Result[T, E], op func(E) Result[T, F]) Result[T, F] {`
	`185`	`+func OrElse[T, E, F any](r Result[T, E], op func(E) Result[T, F]) *Result[T, F] {`
`186`	`186`	`if r.ok {`
`187`	`187`	`return Ok[T, F](r.value)`
`188`	`188`	`}`
`189`	`189`	`return op(r.err)`
`190`	`190`	`}`
`191`	`191`
`192`		`-func Try[T, E, U, F any](r Result[T, E], op func(T) U, closure func(E) Result[U, F]) Result[U, F] {`
	`192`	`+func Try[T, E, U, F any](r Result[T, E], op func(T) U, closure func(E) Result[U, F]) *Result[U, F] {`
`193`	`193`	`if r.ok {`
`194`	`194`	`return Ok[U, F](op(r.value))`
`195`	`195`	`}`
`196`	`196`	`closure(r.err)`
`197`	`197`	`// unreachable`
	`198`	`+ fmt.Println("Result unreachable")`
`198`	`199`	`return closure(r.err)`
`199`	`200`	`}`
`200`	`201`
`201`		`-func (r Result[T, E]) UnwrapOr(def T) T {`
	`202`	`+func (r *Result[T, E]) UnwrapOr(def T) T {`
`202`	`203`	`if r.ok {`
`203`	`204`	`return r.value`
`204`	`205`	`}`
`205`	`206`	`return def`
`206`	`207`	`}`
`207`	`208`
`208`		`-func (r Result[T, E]) UnwrapOrElse(f func(E) T) T {`
	`209`	`+func (r *Result[T, E]) UnwrapOrElse(f func(E) T) T {`
`209`	`210`	`if r.ok {`
`210`	`211`	`return r.value`
`211`	`212`	`}`