feat: Add support for using slices as return types and arguments for …

…closures in Go

Signed-off-by: Felicitas Pojtinger <felicitas@pojtinger.com>

go/pkg/rpc/manager.go

@@ -14,7 +14,7 @@ var (
 	ErrNotAFunction = errors.New("not a function")
 
 	ErrInvalidArgsCount = errors.New("invalid argument count")
-	ErrInvalidArg       = errors.New("invalid argument")
+	ErrInvalidArg       = errors.New("invalid argument, either the type doesn't match or is too complex and can't be inspected")
 
 	ErrClosureDoesNotExist = errors.New("closure does not exist")
 )
@@ -45,15 +45,12 @@ func createClosure(fn interface{}) (func(args ...interface{}) (interface{}, erro
 
 		in := make([]reflect.Value, len(args))
 		for i, arg := range args {
-			if argType := reflect.TypeOf(arg); argType != functionType.In(i) {
-				if argType.ConvertibleTo(functionType.In(i)) {
-					in[i] = reflect.ValueOf(arg).Convert(functionType.In(i))
-				} else {
-					return nil, ErrInvalidArg
-				}
-			} else {
-				in[i] = reflect.ValueOf(arg)
+			convertedArgVal, err := convertValue(reflect.ValueOf(arg), functionType.In(i))
+			if err != nil {
+				return nil, ErrInvalidArg
 			}
+
+			in[i] = convertedArgVal
 		}
 
 		out, err := utils.Call(reflect.ValueOf(fn), in)

go/pkg/rpc/registry.go

@@ -17,6 +17,7 @@ var (
 
 	ErrInvalidFunctionCallPath = errors.New("invalid or empty function call path")
 	ErrInvalidReturn           = errors.New("invalid return, can only return an error or a value and an error")
+	ErrReturnValueTooComplex   = errors.New("invalid return, either the type doesn't match or is too complex and can't be inspected")
 	ErrInvalidArgs             = errors.New("invalid arguments, first argument needs to be a context.Context")
 
 	ErrCannotCallNonFunction = errors.New("can not call non function")
@@ -444,7 +445,12 @@ func (r Registry[R, T]) findLocalFunctionToCallRecursively(
 					errReturnValue := reflect.New(functionType.Out(1))
 
 					if el := rcpRv[0].Elem(); el.IsValid() {
-						valueReturnValue.Elem().Set(el.Convert(valueReturnValue.Type().Elem()))
+						convertedValueReturnType, err := convertValue(el, valueReturnValue.Type().Elem())
+						if err != nil {
+							panic(err)
+						}
+
+						valueReturnValue.Elem().Set(convertedValueReturnType)
 					}
 					errReturnValue.Elem().Set(rcpRv[1])
 
@@ -500,6 +506,34 @@ func findMethodByFunctionCallPathRecursively(root interface{}, functionCallPath
 	return function, nil
 }
 
+func convertValue(srcVal reflect.Value, dstType reflect.Type) (reflect.Value, error) {
+	for srcVal.Kind() == reflect.Interface {
+		srcVal = srcVal.Elem()
+	}
+
+	if srcVal.Type().ConvertibleTo(dstType) {
+		return srcVal.Convert(dstType), nil
+	}
+
+	// We can't convert slices directly, we have to convert each element individually
+	if srcVal.Kind() == reflect.Slice && dstType.Kind() == reflect.Slice {
+		srcLen := srcVal.Len()
+		dstSlice := reflect.MakeSlice(dstType, srcLen, srcLen)
+		for i := 0; i < srcLen; i++ {
+			elem, err := convertValue(srcVal.Index(i), dstType.Elem())
+			if err != nil {
+				return reflect.Value{}, err
+			}
+
+			dstSlice.Index(i).Set(elem)
+		}
+
+		return dstSlice, nil
+	}
+
+	return reflect.Value{}, ErrReturnValueTooComplex
+}
+
 // LinkMessage exposes local RPCs and implements remote RPCs via a message-based transport
 func (r Registry[R, T]) LinkMessage(
 	ctx context.Context, // Context for read, write and in-flight RPC operations