feat(type-manipulation): added cast, castjson and frombytes

Author: Akalanka47000

README.md

@@ -290,6 +290,9 @@ Type manipulation helpers:
 - [CoalesceSliceOrEmpty](#coalescesliceorempty)
 - [CoalesceMap](#coalescemap)
 - [CoalesceMapOrEmpty](#coalescemaporempty)
+- [Cast](#cast)
+= [CastJSON](#castjson)
+- [FromBytes](#frombytes)
 
 Function helpers:
 
@@ -3431,6 +3434,84 @@ result := lo.CoalesceMapOrEmpty(nil, map[string]int{})
 // {}
 ```
 
+### Cast
+
+Converts any type to a given type. If conversion fails, it returns the zero value of the given type. This is a type-safe version of type assertion.
+
+Cast enforces strict type assertion, for example trying to convert a number of 10 to float64 will return 0.0 instead of 10.0.
+
+```go
+var n any = 10
+
+fmt.Println(lo.Cast[int](n) == 10) // true
+
+fmt.Println(lo.Cast[float64](n) == 10.0) // false
+```
+
+[[play](https://go.dev/play/p/IxL5n8tOvTW)]
+
+
+### CastJSON
+
+Converts any type to a given type based on their json representations. It partially fills the target in case they are not directly compatible. Any errors are ignored.
+
+```go
+type TestObject1 struct {
+	Foo string `json:"foo"`
+	Bar int    `json:"bar"`
+}
+
+type TestObject2 struct {
+	Foo string `json:"foo"`
+	Bar int    `json:"bar"`
+	Qux string `json:"qux"`
+}
+
+testObject1 := TestObject1{
+	Foo: "bar",
+	Bar: 42,
+}
+
+testObject2 := TestObject2{
+	Foo: "bar",
+	Bar: 42,
+	Qux: "baz",
+}
+	
+castedTestObject1 := lo.CastJSON[TestObject1](testObject2)
+
+fmt.Println(castedTestObject1.Foo == testObject1.Foo) // true
+fmt.Println(castedTestObject1.Bar == testObject1.Bar) // true
+```
+
+[[play](https://go.dev/play/p/s42Brn9UOug)]
+
+### FromBytes
+
+Converts a byte array to a given type. Ignores any errors.
+
+```go
+bytes, _ := json.Marshal("foo")
+
+fmt.Println(lo.FromBytes[string](bytes) == "foo") // true
+
+type TestObject struct {
+	Foo string `json:"foo"`
+	Bar int    `json:"bar"`
+}
+
+testObject := TestObject{
+	Foo: "bar",
+	Bar: 42,
+}
+
+bytes, _ = json.Marshal(testObject)
+
+fmt.Println(lo.FromBytes[TestObject](bytes) == testObject) // true
+```
+
+[[play](https://go.dev/play/p/T9dfh5QPEzq)]
+
 ### Partial
 
 Returns new function that, when called, has its first argument set to the provided value.

type_manipulation.go

@@ -1,6 +1,9 @@
 package lo
 
-import "reflect"
+import (
+	"encoding/json"
+	"reflect"
+)
 
 // IsNil checks if a value is nil or if it's a reference type with a nil underlying value.
 func IsNil(x any) bool {
@@ -187,3 +190,27 @@ func CoalesceMapOrEmpty[K comparable, V any](v ...map[K]V) map[K]V {
 	}
 	return map[K]V{}
 }
+
+// Converts any type to a given type. If conversion fails, it returns the zero value of the given type. This is a type-safe version of type assertion.
+//
+// Cast enforces strict type assertion, for example trying to convert a number of 10 to float64 will return 0.0 instead of 10.0.
+func Cast[T any](val any) T {
+	if val, ok := val.(T); ok {
+		return val
+	}
+	var zero T
+	return zero
+}
+
+// Converts any type to a given type based on their json representations. It partially fills the target in case they are not directly compatible. Any errors are ignored.
+func CastJSON[T any](val any) T {
+	bytes, _ := json.Marshal(val)
+	return FromBytes[T](bytes)
+}
+
+// Converts a byte array to a given type. Ignores any errors.
+func FromBytes[T any](bytes []byte) T {
+	var v T
+	_ = json.Unmarshal(bytes, &v)
+	return v
+}

type_manipulation_test.go

@@ -1,6 +1,7 @@
 package lo
 
 import (
+	"encoding/json"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -566,3 +567,86 @@ func TestCoalesceMapOrEmpty(t *testing.T) {
 	is.NotNil(result10)
 	is.Equal(map1, result10)
 }
+
+func TestCast(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	var n any = 10
+
+	is.Equal(10, Cast[int](n))
+
+	is.True(Cast[int](n) > 0)
+
+	is.NotZero(Cast[int](n))
+
+	is.Zero(Cast[int](nil))
+
+	is.Zero(Cast[string](n))
+
+	is.Zero(Cast[int32](n))
+
+	is.Zero(Cast[int64](n))
+
+	is.Zero(Cast[uint](n))
+
+	is.Zero(Cast[float32](n))
+
+	is.Zero(Cast[float64](n))
+}
+
+func TestCastJSON(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	type TestObject1 struct {
+		Foo string `json:"foo"`
+		Bar int    `json:"bar"`
+	}
+
+	type TestObject2 struct {
+		Foo string `json:"foo"`
+		Bar int    `json:"bar"`
+		Qux string `json:"qux"`
+	}
+
+	testObject1 := TestObject1{
+		Foo: "bar",
+		Bar: 42,
+	}
+
+	testObject2 := TestObject2{
+		Foo: "bar",
+		Bar: 42,
+		Qux: "baz",
+	}
+
+	is.Equal(testObject1, CastJSON[TestObject1](testObject2))
+}
+
+func TestFromBytes(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	is.Zero(FromBytes[string]([]byte{}))
+
+	bytes, _ := json.Marshal("foo")
+
+	is.Equal("foo", FromBytes[string](bytes))
+
+	bytes, _ = json.Marshal(42)
+
+	is.Equal(42, FromBytes[int](bytes))
+
+	type TestObject struct {
+		Foo string `json:"foo"`
+		Bar int    `json:"bar"`
+	}
+
+	testObject := TestObject{
+		Foo: "bar",
+		Bar: 42,
+	}
+
+	is.Equal(testObject, FromBytes[TestObject]([]byte(`{"foo":"bar","bar":42}`)))
+}