chore: rename UnwrapOrReturn to UnwrapOrThrow, add panicValue

Change-Id: I5463f49f4d7b9595799494fa545ae27ab2ab9223

enum_result.go

@@ -449,28 +449,28 @@ func (r EnumResult[T, E]) CtrlFlow() CtrlFlow[E, T] {
 	return Continue[E, T](r.safeGetT())
 }
 
-// UnwrapOrReturn returns the contained T or panic returns itself.
+// UnwrapOrThrow returns the contained T or panic returns E (panicValue[*any]).
 // NOTE:
 //
 //	If there is an E, that panic should be caught with CatchEnumResult
-func (r EnumResult[T, E]) UnwrapOrReturn() T {
+func (r EnumResult[T, E]) UnwrapOrThrow() T {
 	if r.IsErr() {
 		if !r.isErr || r.value == nil {
 			var e E
 			v := any(e)
-			panic(&v)
+			panic(panicValue[*any]{&v})
 		}
-		panic(r.value)
+		panic(panicValue[*any]{r.value})
 	}
 	return r.safeGetT()
 }
 
-// CatchEnumResult catches panic caused by UnwrapOrReturn and sets E to *EnumResult[U,E]
+// CatchEnumResult catches panic caused by UnwrapOrThrow and sets E to *EnumResult[U,E]
 func CatchEnumResult[U any, E any](result *EnumResult[U, E]) {
 	switch p := recover().(type) {
 	case nil:
-	case *any:
-		result.value = p
+	case panicValue[*any]:
+		result.value = p.value
 		result.isErr = true
 	default:
 		panic(p)

enum_result_test.go

@@ -43,21 +43,21 @@ func TestEnumResultIsValid(t *testing.T) {
 	assert.True(t, r2.IsValid())
 }
 
-func TestEnumResultUnwrapOrReturn_1(t *testing.T) {
+func TestEnumResultUnwrapOrThrow_1(t *testing.T) {
 	var r gust.EnumResult[string, string]
 	defer func() {
 		assert.Equal(t, gust.EnumErr[string, string]("err"), r)
 	}()
 	defer gust.CatchEnumResult[string, string](&r)
 	var r1 = gust.EnumOk[int, string](1)
-	var v1 = r1.UnwrapOrReturn()
+	var v1 = r1.UnwrapOrThrow()
 	assert.Equal(t, 1, v1)
 	var r2 = gust.EnumErr[int, string]("err")
-	var v2 = r2.UnwrapOrReturn()
+	var v2 = r2.UnwrapOrThrow()
 	assert.Equal(t, 0, v2)
 }
 
-func TestEnumResultUnwrapOrReturn_2(t *testing.T) {
+func TestEnumResultUnwrapOrThrow_2(t *testing.T) {
 	defer func() {
 		assert.Equal(t, "panic text", recover())
 	}()

result.go

@@ -329,28 +329,28 @@ func (r Result[T]) CtrlFlow() CtrlFlow[error, T] {
 	return Continue[error, T](r.inner.safeGetT())
 }
 
-// UnwrapOrReturn returns the contained T or panic returns itself.
+// UnwrapOrThrow returns the contained T or panic returns error (panicValue[*any]).
 // NOTE:
 //
 //	If there is an error, that panic should be caught with CatchResult
-func (r Result[T]) UnwrapOrReturn() T {
+func (r Result[T]) UnwrapOrThrow() T {
 	if r.IsErr() {
 		if !r.inner.isErr || r.inner.value == nil {
 			var err error
 			v := any(toError(err))
-			panic(&v)
+			panic(panicValue[*any]{&v})
 		}
-		panic(r.inner.value)
+		panic(panicValue[*any]{r.inner.value})
 	}
 	return r.inner.safeGetT()
 }
 
-// CatchResult catches panic caused by UnwrapOrReturn and sets error to *Result[U]
+// CatchResult catches panic caused by UnwrapOrThrow and sets error to *Result[U]
 func CatchResult[U any](result *Result[U]) {
 	switch p := recover().(type) {
 	case nil:
-	case *any:
-		result.inner.value = p
+	case panicValue[*any]:
+		result.inner.value = p.value
 		result.inner.isErr = true
 	default:
 		panic(p)

result_test.go

@@ -43,21 +43,21 @@ func TestResultIsValid(t *testing.T) {
 	assert.True(t, r2.IsValid())
 }
 
-func TestResultUnwrapOrReturn_1(t *testing.T) {
+func TestResultUnwrapOrThrow_1(t *testing.T) {
 	var r gust.Result[string]
 	defer func() {
 		assert.Equal(t, gust.Err[string]("err"), r)
 	}()
 	defer gust.CatchResult[string](&r)
 	var r1 = gust.Ok(1)
-	var v1 = r1.UnwrapOrReturn()
+	var v1 = r1.UnwrapOrThrow()
 	assert.Equal(t, 1, v1)
 	var r2 = gust.Err[int]("err")
-	var v2 = r2.UnwrapOrReturn()
+	var v2 = r2.UnwrapOrThrow()
 	assert.Equal(t, 0, v2)
 }
 
-func TestResultUnwrapOrReturn_2(t *testing.T) {
+func TestResultUnwrapOrThrow_2(t *testing.T) {
 	defer func() {
 		assert.Equal(t, "panic text", recover())
 	}()
@@ -66,16 +66,16 @@ func TestResultUnwrapOrReturn_2(t *testing.T) {
 	panic("panic text")
 }
 
-func TestResultUnwrapOrReturn_3(t *testing.T) {
+func TestResultUnwrapOrThrow_3(t *testing.T) {
 	var r gust.EnumResult[string, error]
 	defer func() {
 		assert.Equal(t, gust.EnumErr[string, error](gust.ToErrBox("err")), r)
 	}()
 	defer gust.CatchEnumResult[string, error](&r)
 	var r1 = gust.Ok(1)
-	var v1 = r1.UnwrapOrReturn()
+	var v1 = r1.UnwrapOrThrow()
 	assert.Equal(t, 1, v1)
 	var r2 = gust.Err[int]("err")
-	var v2 = r2.UnwrapOrReturn()
+	var v2 = r2.UnwrapOrThrow()
 	assert.Equal(t, 0, v2)
 }

utils.go

@@ -26,3 +26,7 @@ func initNilPtr(v reflect.Value) (done bool) {
 		v = v.Elem()
 	}
 }
+
+type panicValue[T any] struct {
+	value T
+}