refactor: type Option change initialize behavior

initdc · initdc · commit 8aea85e88cf8 · 2025-12-01T18:58:54.000+08:00
diff --git a/option/option.go b/option/option.go
@@ -1,6 +1,8 @@
 package option
 
 import (
+	"fmt"
+
 	"github.com/initdc/types/result"
 )
 
@@ -10,16 +12,16 @@ type Option[T any] struct {
 	assigned bool
 }
 
-func Some[T any](v T) Option[T] {
-	return Option[T]{
+func Some[T any](v T) *Option[T] {
+	return &Option[T]{
 		value:    v,
 		some:     true,
 		assigned: true,
 	}
 }
 
-func None[T any]() Option[T] {
-	return Option[T]{
+func None[T any]() *Option[T] {
+	return &Option[T]{
 		some:     false,
 		assigned: true,
 	}
@@ -54,7 +56,7 @@ func (o Option[T]) IsSome() bool {
 	return o.some
 }
 
-func (o Option[T]) IsSomeAnd(f func(T) bool) bool {
+func (o *Option[T]) IsSomeAnd(f func(T) bool) bool {
 	if !o.some {
 		return false
 	}
@@ -65,42 +67,42 @@ func (o Option[T]) IsNone() bool {
 	return !o.some
 }
 
-func (o Option[T]) IsNoneOr(f func(T) bool) bool {
+func (o *Option[T]) IsNoneOr(f func(T) bool) bool {
 	if !o.some {
 		return true
 	}
 	return f(o.value)
 }
 
-func (o Option[T]) Expect(msg string) T {
+func (o *Option[T]) Expect(msg string) T {
 	if o.some {
 		return o.value
 	}
 	panic(msg)
 }
 
-func (o Option[T]) Unwrap() T {
+func (o *Option[T]) Unwrap() T {
 	if o.some {
 		return o.value
 	}
 	panic("called Option.Unwrap() on a None value")
 }
 
-func (o Option[T]) UnwrapOr(def T) T {
+func (o *Option[T]) UnwrapOr(def T) T {
 	if o.some {
 		return o.value
 	}
 	return def
 }
 
-func (o Option[T]) UnwrapOrElse(f func() T) T {
+func (o *Option[T]) UnwrapOrElse(f func() T) T {
 	if o.some {
 		return o.value
 	}
 	return f()
 }
 
-func (o Option[T]) UnwrapOrDefault() T {
+func (o *Option[T]) UnwrapOrDefault() T {
 	if o.some {
 		return o.value
 	}
@@ -110,158 +112,159 @@ func (o Option[T]) UnwrapOrDefault() T {
 
 type F[U any] func(U) U
 
-func To[T, U any](o Option[T], f func(T) U) Option[U] {
+func To[T, U any](o *Option[T], f func(T) U) *Option[U] {
 	if o.some {
 		return Some[U](f(o.value))
 	}
 	return None[U]()
 }
 
-func (o Option[U]) Map(f F[U]) Option[U] {
+func (o *Option[U]) Map(f F[U]) *Option[U] {
 	if o.some {
 		return Some[U](f(o.value))
 	}
 	return None[U]()
 }
 
-func OptionMap[T, U any](o Option[T], f func(T) U) Option[U] {
+func OptionMap[T, U any](o *Option[T], f func(T) U) *Option[U] {
 	if o.some {
 		return Some[U](f(o.value))
 	}
 	return None[U]()
 }
 
-func (o Option[T]) Inspect(f func(T)) Option[T] {
+func (o *Option[T]) Inspect(f func(T)) *Option[T] {
 	if o.some {
 		f(o.value)
 	}
 	return o
 }
 
-func (o Option[U]) MapOr(def U, f F[U]) U {
+func (o *Option[U]) MapOr(def U, f F[U]) U {
 	if o.some {
 		return f(o.value)
 	}
 	return def
 }
 
-func OptionMapOr[T, U any](o Option[T], def U, f func(T) U) U {
+func OptionMapOr[T, U any](o *Option[T], def U, f func(T) U) U {
 	if o.some {
 		return f(o.value)
 	}
 	return def
 }
 
-func (o Option[U]) MapOrElse(def func() U, f F[U]) U {
+func (o *Option[U]) MapOrElse(def func() U, f F[U]) U {
 	if o.some {
 		return f(o.value)
 	}
 	return def()
 }
 
-func OptionMapOrElse[T, U any](o Option[T], def func() U, f func(T) U) U {
+func OptionMapOrElse[T, U any](o *Option[T], def func() U, f func(T) U) U {
 	if o.some {
 		return f(o.value)
 	}
 	return def()
 }
 
-func (o Option[U]) MapOrDefault(f F[U]) U {
+func (o *Option[U]) MapOrDefault(f F[U]) U {
 	if o.some {
 		return f(o.value)
 	}
 	var zero U
 	return zero
 }
 
-func OptionMapOrDefault[T, U any](o Option[T], f func(T) U) U {
+func OptionMapOrDefault[T, U any](o *Option[T], f func(T) U) U {
 	if o.some {
 		return f(o.value)
 	}
 	var zero U
 	return zero
 }
 
-func OkOr[T, E any](o Option[T], err E) result.Result[T, E] {
+func OkOr[T, E any](o *Option[T], err E) *result.Result[T, E] {
 	if o.some {
 		return result.Ok[T, E](o.value)
 	}
 	return result.Err[T, E](err)
 }
 
-func OkOrElse[T, E any](o Option[T], err func() E) result.Result[T, E] {
+func OkOrElse[T, E any](o *Option[T], err func() E) *result.Result[T, E] {
 	if o.some {
 		return result.Ok[T, E](o.value)
 	}
 	return result.Err[T, E](err())
 }
 
-func (o Option[U]) And(optb Option[U]) Option[U] {
+func (o *Option[U]) And(optb *Option[U]) *Option[U] {
 	if o.some {
 		return optb
 	}
 	return None[U]()
 }
 
-func OptionAnd[T, U any](o Option[T], optb Option[U]) Option[U] {
+func OptionAnd[T, U any](o *Option[T], optb *Option[U]) *Option[U] {
 	if o.some {
 		return optb
 	}
 	return None[U]()
 }
 
-func (o Option[U]) AndThen(optb Option[U], f func(U) Option[U]) Option[U] {
+func (o *Option[U]) AndThen(optb *Option[U], f func(U) *Option[U]) *Option[U] {
 	if o.some {
 		return f(o.value)
 	}
 	return None[U]()
 }
 
-func OptionAndThen[T, U any](o Option[T], f func(T) Option[U]) Option[U] {
+func OptionAndThen[T, U any](o *Option[T], f func(T) *Option[U]) *Option[U] {
 	if o.some {
 		return f(o.value)
 	}
 	return None[U]()
 }
 
-func (o Option[T]) Filter(predicate func(T) bool) Option[T] {
+func (o *Option[T]) Filter(predicate func(T) bool) *Option[T] {
 	if o.some && predicate(o.value) {
 		return Some[T](o.value)
 	}
 	return None[T]()
 }
 
-func (o Option[T]) Or(optb Option[T]) Option[T] {
+func (o *Option[T]) Or(optb *Option[T]) *Option[T] {
 	if o.some {
 		return o
 	}
 	return optb
 }
 
-func (o Option[T]) OrElse(f func() Option[T]) Option[T] {
+func (o *Option[T]) OrElse(f func() *Option[T]) *Option[T] {
 	if o.some {
 		return o
 	}
 	return f()
 }
 
-func TryOr[T, U, E any](o Option[T], f func(T) U, e E) result.Result[U, E] {
+func TryOr[T, U, E any](o *Option[T], f func(T) U, e E) *result.Result[U, E] {
 	if o.some {
 		return result.Ok[U, E](f(o.value))
 	}
 	return result.Err[U, E](e)
 }
 
-func TryOrElse[T, U, E any](o Option[T], f func(T) U, closure func() result.Result[U, E]) result.Result[U, E] {
+func TryOrElse[T, U, E any](o *Option[T], f func(T) U, closure func() *result.Result[U, E]) *result.Result[U, E] {
 	if o.some {
 		return result.Ok[U, E](f(o.value))
 	}
 	closure()
 	// unreachable
+	fmt.Println("Option unreachable")
 	return closure()
 }
 
-func (o Option[T]) Xor(optb Option[T]) Option[T] {
+func (o *Option[T]) Xor(optb *Option[T]) *Option[T] {
 	if o.some && !optb.some {
 		return o
 	}
@@ -306,14 +309,14 @@ func (o *Option[T]) GetOrInsertWith(f func() T) *T {
 	return &o.value
 }
 
-func (o *Option[T]) Take() Option[T] {
+func (o *Option[T]) Take() *Option[T] {
 	var cp = *o
-	*o = None[T]()
-	return cp
+	*o = *(None[T]())
+	return &cp
 }
 
-func (o *Option[T]) Replace(value T) Option[T] {
+func (o *Option[T]) Replace(value T) *Option[T] {
 	var cp = *o
-	*o = Some[T](value)
-	return cp
+	*o = *(Some[T](value))
+	return &cp
 }
diff --git a/option/option_test.go b/option/option_test.go
@@ -22,8 +22,8 @@ func TestSome(t *testing.T) {
 	c := Some[int](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 TestNone(t *testing.T) {
@@ -38,8 +38,8 @@ func TestNone(t *testing.T) {
 	c := None[int]()
 
 	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 TestIsSome(t *testing.T) {
@@ -221,7 +221,7 @@ func TestOptionAnd(t *testing.T) {
 }
 
 func TestOptionAndThen(t *testing.T) {
-	sqThenToString := func(x int) Option[string] {
+	sqThenToString := func(x int) *Option[string] {
 		if x > 100 || x < 0 {
 			return None[string]()
 		}
@@ -260,8 +260,8 @@ func TestOr(t *testing.T) {
 }
 
 func TestOrElse(t *testing.T) {
-	nobody := func() Option[int] { return None[int]() }
-	vikings := func() Option[int] { return Some(42) }
+	nobody := func() *Option[int] { return None[int]() }
+	vikings := func() *Option[int] { return Some(42) }
 
 	assert.Equal(t, Some(10).OrElse(vikings), Some(10))
 	assert.Equal(t, None[int]().OrElse(vikings), Some(42))
@@ -279,7 +279,7 @@ func TestTryOr(t *testing.T) {
 
 func TestTryOrElse(t *testing.T) {
 	f := func(x int) float32 { return float32(x) * 2 }
-	closure := func() result.Result[float32, string] { return result.Err[float32, string]("bad") }
+	closure := func() *result.Result[float32, string] { return result.Err[float32, string]("bad") }
 	x := Some(2)
 	y := None[int]()
 
@@ -324,7 +324,7 @@ func TestGetOrInsert(t *testing.T) {
 	assert.Equal(t, *y, 5)
 
 	*y = 7
-	assert.Equal(t, x, Some[int](7))
+	assert.Equal(t, &x, Some[int](7))
 }
 
 func TestGetOrInsertDefault(t *testing.T) {
@@ -334,7 +334,7 @@ func TestGetOrInsertDefault(t *testing.T) {
 	assert.Equal(t, *y, 0)
 
 	*y = 7
-	assert.Equal(t, x, Some[int](7))
+	assert.Equal(t, &x, Some[int](7))
 }
 
 func TestGetOrInsertWith(t *testing.T) {
@@ -344,33 +344,33 @@ func TestGetOrInsertWith(t *testing.T) {
 	assert.Equal(t, *y, 5)
 
 	*y = 7
-	assert.Equal(t, x, Some[int](7))
+	assert.Equal(t, &x, Some[int](7))
 }
 
 func TestTake(t *testing.T) {
 	var x Option[int]
 	x.Some(2)
 	y := x.Take()
-	assert.Equal(t, x, None[int]())
+	assert.Equal(t, &x, None[int]())
 	assert.Equal(t, y, Some(2))
 
 	var x2 Option[int]
 	x2.None()
 	y2 := x2.Take()
-	assert.Equal(t, x2, None[int]())
+	assert.Equal(t, &x2, None[int]())
 	assert.Equal(t, y2, None[int]())
 }
 
 func TestReplace(t *testing.T) {
 	var x Option[int]
 	x.Some(2)
 	old := x.Replace(5)
-	assert.Equal(t, x, Some(5))
+	assert.Equal(t, &x, Some(5))
 	assert.Equal(t, old, Some(2))
 
 	var x2 Option[int]
 	x2.None()
 	old2 := x2.Replace(3)
-	assert.Equal(t, x2, Some(3))
+	assert.Equal(t, &x2, Some(3))
 	assert.Equal(t, old2, None[int]())
 }

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`package option`
`2`	`2`
`3`	`3`	`import (`
	`4`	`+ "fmt"`
	`5`	`+`
`4`	`6`	`"github.com/initdc/types/result"`
`5`	`7`	`)`
`6`	`8`
`@@ -10,16 +12,16 @@ type Option[T any] struct {`
`10`	`12`	`assigned bool`
`11`	`13`	`}`
`12`	`14`
`13`		`-func Some[T any](v T) Option[T] {`
`14`		`- return Option[T]{`
	`15`	`+func Some[T any](v T) *Option[T] {`
	`16`	`+ return &Option[T]{`
`15`	`17`	`value: v,`
`16`	`18`	`some: true,`
`17`	`19`	`assigned: true,`
`18`	`20`	`}`
`19`	`21`	`}`
`20`	`22`
`21`		`-func None[T any]() Option[T] {`
`22`		`- return Option[T]{`
	`23`	`+func None[T any]() *Option[T] {`
	`24`	`+ return &Option[T]{`
`23`	`25`	`some: false,`
`24`	`26`	`assigned: true,`
`25`	`27`	`}`
`@@ -54,7 +56,7 @@ func (o Option[T]) IsSome() bool {`
`54`	`56`	`return o.some`
`55`	`57`	`}`
`56`	`58`
`57`		`-func (o Option[T]) IsSomeAnd(f func(T) bool) bool {`
	`59`	`+func (o *Option[T]) IsSomeAnd(f func(T) bool) bool {`
`58`	`60`	`if !o.some {`
`59`	`61`	`return false`
`60`	`62`	`}`
`@@ -65,42 +67,42 @@ func (o Option[T]) IsNone() bool {`
`65`	`67`	`return !o.some`
`66`	`68`	`}`
`67`	`69`
`68`		`-func (o Option[T]) IsNoneOr(f func(T) bool) bool {`
	`70`	`+func (o *Option[T]) IsNoneOr(f func(T) bool) bool {`
`69`	`71`	`if !o.some {`
`70`	`72`	`return true`
`71`	`73`	`}`
`72`	`74`	`return f(o.value)`
`73`	`75`	`}`
`74`	`76`
`75`		`-func (o Option[T]) Expect(msg string) T {`
	`77`	`+func (o *Option[T]) Expect(msg string) T {`
`76`	`78`	`if o.some {`
`77`	`79`	`return o.value`
`78`	`80`	`}`
`79`	`81`	`panic(msg)`
`80`	`82`	`}`
`81`	`83`
`82`		`-func (o Option[T]) Unwrap() T {`
	`84`	`+func (o *Option[T]) Unwrap() T {`
`83`	`85`	`if o.some {`
`84`	`86`	`return o.value`
`85`	`87`	`}`
`86`	`88`	`panic("called Option.Unwrap() on a None value")`
`87`	`89`	`}`
`88`	`90`
`89`		`-func (o Option[T]) UnwrapOr(def T) T {`
	`91`	`+func (o *Option[T]) UnwrapOr(def T) T {`
`90`	`92`	`if o.some {`
`91`	`93`	`return o.value`
`92`	`94`	`}`
`93`	`95`	`return def`
`94`	`96`	`}`
`95`	`97`
`96`		`-func (o Option[T]) UnwrapOrElse(f func() T) T {`
	`98`	`+func (o *Option[T]) UnwrapOrElse(f func() T) T {`
`97`	`99`	`if o.some {`
`98`	`100`	`return o.value`
`99`	`101`	`}`
`100`	`102`	`return f()`
`101`	`103`	`}`
`102`	`104`
`103`		`-func (o Option[T]) UnwrapOrDefault() T {`
	`105`	`+func (o *Option[T]) UnwrapOrDefault() T {`
`104`	`106`	`if o.some {`
`105`	`107`	`return o.value`
`106`	`108`	`}`
`@@ -110,158 +112,159 @@ func (o Option[T]) UnwrapOrDefault() T {`
`110`	`112`
`111`	`113`	`type F[U any] func(U) U`
`112`	`114`
`113`		`-func To[T, U any](o Option[T], f func(T) U) Option[U] {`
	`115`	`+func To[T, U any](o Option[T], f func(T) U) Option[U] {`
`114`	`116`	`if o.some {`
`115`	`117`	`return Some[U](f(o.value))`
`116`	`118`	`}`
`117`	`119`	`return None[U]()`
`118`	`120`	`}`
`119`	`121`
`120`		`-func (o Option[U]) Map(f F[U]) Option[U] {`
	`122`	`+func (o Option[U]) Map(f F[U]) Option[U] {`
`121`	`123`	`if o.some {`
`122`	`124`	`return Some[U](f(o.value))`
`123`	`125`	`}`
`124`	`126`	`return None[U]()`
`125`	`127`	`}`
`126`	`128`
`127`		`-func OptionMap[T, U any](o Option[T], f func(T) U) Option[U] {`
	`129`	`+func OptionMap[T, U any](o Option[T], f func(T) U) Option[U] {`
`128`	`130`	`if o.some {`
`129`	`131`	`return Some[U](f(o.value))`
`130`	`132`	`}`
`131`	`133`	`return None[U]()`
`132`	`134`	`}`
`133`	`135`
`134`		`-func (o Option[T]) Inspect(f func(T)) Option[T] {`
	`136`	`+func (o Option[T]) Inspect(f func(T)) Option[T] {`
`135`	`137`	`if o.some {`
`136`	`138`	`f(o.value)`
`137`	`139`	`}`
`138`	`140`	`return o`
`139`	`141`	`}`
`140`	`142`
`141`		`-func (o Option[U]) MapOr(def U, f F[U]) U {`
	`143`	`+func (o *Option[U]) MapOr(def U, f F[U]) U {`
`142`	`144`	`if o.some {`
`143`	`145`	`return f(o.value)`
`144`	`146`	`}`
`145`	`147`	`return def`
`146`	`148`	`}`
`147`	`149`
`148`		`-func OptionMapOr[T, U any](o Option[T], def U, f func(T) U) U {`
	`150`	`+func OptionMapOr[T, U any](o *Option[T], def U, f func(T) U) U {`
`149`	`151`	`if o.some {`
`150`	`152`	`return f(o.value)`
`151`	`153`	`}`
`152`	`154`	`return def`
`153`	`155`	`}`
`154`	`156`
`155`		`-func (o Option[U]) MapOrElse(def func() U, f F[U]) U {`
	`157`	`+func (o *Option[U]) MapOrElse(def func() U, f F[U]) U {`
`156`	`158`	`if o.some {`
`157`	`159`	`return f(o.value)`
`158`	`160`	`}`
`159`	`161`	`return def()`
`160`	`162`	`}`
`161`	`163`
`162`		`-func OptionMapOrElse[T, U any](o Option[T], def func() U, f func(T) U) U {`
	`164`	`+func OptionMapOrElse[T, U any](o *Option[T], def func() U, f func(T) U) U {`
`163`	`165`	`if o.some {`
`164`	`166`	`return f(o.value)`
`165`	`167`	`}`
`166`	`168`	`return def()`
`167`	`169`	`}`
`168`	`170`
`169`		`-func (o Option[U]) MapOrDefault(f F[U]) U {`
	`171`	`+func (o *Option[U]) MapOrDefault(f F[U]) U {`
`170`	`172`	`if o.some {`
`171`	`173`	`return f(o.value)`
`172`	`174`	`}`
`173`	`175`	`var zero U`
`174`	`176`	`return zero`
`175`	`177`	`}`
`176`	`178`
`177`		`-func OptionMapOrDefault[T, U any](o Option[T], f func(T) U) U {`
	`179`	`+func OptionMapOrDefault[T, U any](o *Option[T], f func(T) U) U {`
`178`	`180`	`if o.some {`
`179`	`181`	`return f(o.value)`
`180`	`182`	`}`
`181`	`183`	`var zero U`
`182`	`184`	`return zero`
`183`	`185`	`}`
`184`	`186`
`185`		`-func OkOr[T, E any](o Option[T], err E) result.Result[T, E] {`
	`187`	`+func OkOr[T, E any](o Option[T], err E) result.Result[T, E] {`
`186`	`188`	`if o.some {`
`187`	`189`	`return result.Ok[T, E](o.value)`
`188`	`190`	`}`
`189`	`191`	`return result.Err[T, E](err)`
`190`	`192`	`}`
`191`	`193`
`192`		`-func OkOrElse[T, E any](o Option[T], err func() E) result.Result[T, E] {`
	`194`	`+func OkOrElse[T, E any](o Option[T], err func() E) result.Result[T, E] {`
`193`	`195`	`if o.some {`
`194`	`196`	`return result.Ok[T, E](o.value)`
`195`	`197`	`}`
`196`	`198`	`return result.Err[T, E](err())`
`197`	`199`	`}`
`198`	`200`
`199`		`-func (o Option[U]) And(optb Option[U]) Option[U] {`
	`201`	`+func (o Option[U]) And(optb Option[U]) *Option[U] {`
`200`	`202`	`if o.some {`
`201`	`203`	`return optb`
`202`	`204`	`}`
`203`	`205`	`return None[U]()`
`204`	`206`	`}`
`205`	`207`
`206`		`-func OptionAnd[T, U any](o Option[T], optb Option[U]) Option[U] {`
	`208`	`+func OptionAnd[T, U any](o Option[T], optb Option[U]) *Option[U] {`
`207`	`209`	`if o.some {`
`208`	`210`	`return optb`
`209`	`211`	`}`
`210`	`212`	`return None[U]()`
`211`	`213`	`}`
`212`	`214`
`213`		`-func (o Option[U]) AndThen(optb Option[U], f func(U) Option[U]) Option[U] {`
	`215`	`+func (o Option[U]) AndThen(optb Option[U], f func(U) Option[U]) Option[U] {`
`214`	`216`	`if o.some {`
`215`	`217`	`return f(o.value)`
`216`	`218`	`}`
`217`	`219`	`return None[U]()`
`218`	`220`	`}`
`219`	`221`
`220`		`-func OptionAndThen[T, U any](o Option[T], f func(T) Option[U]) Option[U] {`
	`222`	`+func OptionAndThen[T, U any](o Option[T], f func(T) Option[U]) *Option[U] {`
`221`	`223`	`if o.some {`
`222`	`224`	`return f(o.value)`
`223`	`225`	`}`
`224`	`226`	`return None[U]()`
`225`	`227`	`}`
`226`	`228`
`227`		`-func (o Option[T]) Filter(predicate func(T) bool) Option[T] {`
	`229`	`+func (o Option[T]) Filter(predicate func(T) bool) Option[T] {`
`228`	`230`	`if o.some && predicate(o.value) {`
`229`	`231`	`return Some[T](o.value)`
`230`	`232`	`}`
`231`	`233`	`return None[T]()`
`232`	`234`	`}`
`233`	`235`
`234`		`-func (o Option[T]) Or(optb Option[T]) Option[T] {`
	`236`	`+func (o Option[T]) Or(optb Option[T]) *Option[T] {`
`235`	`237`	`if o.some {`
`236`	`238`	`return o`
`237`	`239`	`}`
`238`	`240`	`return optb`
`239`	`241`	`}`
`240`	`242`
`241`		`-func (o Option[T]) OrElse(f func() Option[T]) Option[T] {`
	`243`	`+func (o Option[T]) OrElse(f func() Option[T]) *Option[T] {`
`242`	`244`	`if o.some {`
`243`	`245`	`return o`
`244`	`246`	`}`
`245`	`247`	`return f()`
`246`	`248`	`}`
`247`	`249`
`248`		`-func TryOr[T, U, E any](o Option[T], f func(T) U, e E) result.Result[U, E] {`
	`250`	`+func TryOr[T, U, E any](o Option[T], f func(T) U, e E) result.Result[U, E] {`
`249`	`251`	`if o.some {`
`250`	`252`	`return result.Ok[U, E](f(o.value))`
`251`	`253`	`}`
`252`	`254`	`return result.Err[U, E](e)`
`253`	`255`	`}`
`254`	`256`
`255`		`-func TryOrElse[T, U, E any](o Option[T], f func(T) U, closure func() result.Result[U, E]) result.Result[U, E] {`
	`257`	`+func TryOrElse[T, U, E any](o Option[T], f func(T) U, closure func() result.Result[U, E]) *result.Result[U, E] {`
`256`	`258`	`if o.some {`
`257`	`259`	`return result.Ok[U, E](f(o.value))`
`258`	`260`	`}`
`259`	`261`	`closure()`
`260`	`262`	`// unreachable`
	`263`	`+ fmt.Println("Option unreachable")`
`261`	`264`	`return closure()`
`262`	`265`	`}`
`263`	`266`
`264`		`-func (o Option[T]) Xor(optb Option[T]) Option[T] {`
	`267`	`+func (o Option[T]) Xor(optb Option[T]) *Option[T] {`
`265`	`268`	`if o.some && !optb.some {`
`266`	`269`	`return o`
`267`	`270`	`}`
`@@ -306,14 +309,14 @@ func (o Option[T]) GetOrInsertWith(f func() T) T {`
`306`	`309`	`return &o.value`
`307`	`310`	`}`
`308`	`311`
`309`		`-func (o *Option[T]) Take() Option[T] {`
	`312`	`+func (o Option[T]) Take() Option[T] {`
`310`	`313`	`var cp = *o`
`311`		`- *o = None[T]()`
`312`		`- return cp`
	`314`	`+ o = (None[T]())`
	`315`	`+ return &cp`
`313`	`316`	`}`
`314`	`317`
`315`		`-func (o *Option[T]) Replace(value T) Option[T] {`
	`318`	`+func (o Option[T]) Replace(value T) Option[T] {`
`316`	`319`	`var cp = *o`
`317`		`- *o = Some[T](value)`
`318`		`- return cp`
	`320`	`+ o = (Some[T](value))`
	`321`	`+ return &cp`
`319`	`322`	`}`