Fix Must to receives 'err any' #99

errors.go

@@ -1,69 +1,62 @@
 package lo
 
-// Must is a helper that wraps a call to a function returning a value and an error
+// must panics if err is error or false.
-// and panics if the error is non-nil.
+func must(err any) {
-func Must[T any](val T, err error) T {
+	b, isBool := err.(bool)
-	if err != nil {
+	if isBool && !b {
-		panic(err)
+		panic("not ok")
 	}
 
+	e, isError := err.(error)
+	if isError {
+		panic(e)
+	}
+}
+
+// Must is a helper that wraps a call to a function returning a value and an error
+// and panics if err is error or false.
+func Must[T any](val T, err any) T {
+	must(err)
 	return val
 }
 
 // Must0 has the same behavior than Must, but callback returns no variable.
-func Must0(err error) {
+func Must0(err any) {
-	if err != nil {
+	must(err)
-		panic(err)
-	}
 }
 
 // Must1 is an alias to Must
-func Must1[T any](val T, err error) T {
+func Must1[T any](val T, err any) T {
 	return Must(val, err)
 }
 
 // Must2 has the same behavior than Must, but callback returns 2 variable2.
-func Must2[T1 any, T2 any](val1 T1, val2 T2, err error) (T1, T2) {
+func Must2[T1 any, T2 any](val1 T1, val2 T2, err any) (T1, T2) {
-	if err != nil {
+	must(err)
-		panic(err)
-	}
-
 	return val1, val2
 }
 
 // Must3 has the same behavior than Must, but callback returns 2 variable2.
-func Must3[T1 any, T2 any, T3 any](val1 T1, val2 T2, val3 T3, err error) (T1, T2, T3) {
+func Must3[T1 any, T2 any, T3 any](val1 T1, val2 T2, val3 T3, err any) (T1, T2, T3) {
-	if err != nil {
+	must(err)
-		panic(err)
-	}
-
 	return val1, val2, val3
 }
 
 // Must4 has the same behavior than Must, but callback returns 2 variable2.
-func Must4[T1 any, T2 any, T3 any, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err error) (T1, T2, T3, T4) {
+func Must4[T1 any, T2 any, T3 any, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any) (T1, T2, T3, T4) {
-	if err != nil {
+	must(err)
-		panic(err)
-	}
-
 	return val1, val2, val3, val4
 }
 
 // Must5 has the same behavior than Must, but callback returns 2 variable2.
-func Must5[T1 any, T2 any, T3 any, T4 any, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err error) (T1, T2, T3, T4, T5) {
+func Must5[T1 any, T2 any, T3 any, T4 any, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any) (T1, T2, T3, T4, T5) {
-	if err != nil {
+	must(err)
-		panic(err)
-	}
-
 	return val1, val2, val3, val4, val5
 }
 
 // Must6 has the same behavior than Must, but callback returns 2 variable2.
-func Must6[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err error) (T1, T2, T3, T4, T5, T6) {
+func Must6[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any) (T1, T2, T3, T4, T5, T6) {
-	if err != nil {
+	must(err)
-		panic(err)
-	}
-
 	return val1, val2, val3, val4, val5, val6
 }
 

errors_test.go

@@ -14,6 +14,11 @@ func TestMust(t *testing.T) {
 	is.Panics(func() {
 		Must("", errors.New("something went wrong"))
 	})
+
+	is.Equal(1, Must(1, true))
+	is.Panics(func() {
+		Must(1, false)
+	})
 }
 
 func TestMustX(t *testing.T) {
@@ -108,6 +113,78 @@ func TestMustX(t *testing.T) {
 			Must6(1, 2, 3, 4, 5, 6, nil)
 		})
 	}
+
+	{
+		is.Panics(func() {
+			Must0(false)
+		})
+		is.NotPanics(func() {
+			Must0(true)
+		})
+	}
+
+	{
+		val1 := Must1(1, true)
+		is.Equal(1, val1)
+		is.Panics(func() {
+			Must1(1, false)
+		})
+	}
+
+	{
+		val1, val2 := Must2(1, 2, true)
+		is.Equal(1, val1)
+		is.Equal(2, val2)
+		is.Panics(func() {
+			Must2(1, 2, false)
+		})
+	}
+
+	{
+		val1, val2, val3 := Must3(1, 2, 3, true)
+		is.Equal(1, val1)
+		is.Equal(2, val2)
+		is.Equal(3, val3)
+		is.Panics(func() {
+			Must3(1, 2, 3, false)
+		})
+	}
+
+	{
+		val1, val2, val3, val4 := Must4(1, 2, 3, 4, true)
+		is.Equal(1, val1)
+		is.Equal(2, val2)
+		is.Equal(3, val3)
+		is.Equal(4, val4)
+		is.Panics(func() {
+			Must4(1, 2, 3, 4, false)
+		})
+	}
+
+	{
+		val1, val2, val3, val4, val5 := Must5(1, 2, 3, 4, 5, true)
+		is.Equal(1, val1)
+		is.Equal(2, val2)
+		is.Equal(3, val3)
+		is.Equal(4, val4)
+		is.Equal(5, val5)
+		is.Panics(func() {
+			Must5(1, 2, 3, 4, 5, false)
+		})
+	}
+
+	{
+		val1, val2, val3, val4, val5, val6 := Must6(1, 2, 3, 4, 5, 6, true)
+		is.Equal(1, val1)
+		is.Equal(2, val2)
+		is.Equal(3, val3)
+		is.Equal(4, val4)
+		is.Equal(5, val5)
+		is.Equal(6, val6)
+		is.Panics(func() {
+			Must6(1, 2, 3, 4, 5, 6, false)
+		})
+	}
 }
 
 func TestTry(t *testing.T) {