Adopt *new(T) pattern for zero results

Author: cschleiden

client/client.go

@@ -139,19 +139,16 @@ func (c *client) WaitForWorkflowInstance(ctx context.Context, instance *workflow
 }
 
 func GetWorkflowResult[T any](ctx context.Context, c Client, instance *workflow.Instance, timeout time.Duration) (T, error) {
-	// Zero result
-	var z T
-
 	if err := c.WaitForWorkflowInstance(ctx, instance, timeout); err != nil {
-		return z, fmt.Errorf("workflow did not finish in time: %w", err)
+		return *new(T), fmt.Errorf("workflow did not finish in time: %w", err)
 	}
 
 	ic := c.(*client)
 	b := ic.backend
 
 	h, err := b.GetWorkflowInstanceHistory(ctx, instance, nil)
 	if err != nil {
-		return z, fmt.Errorf("getting workflow history: %w", err)
+		return *new(T), fmt.Errorf("getting workflow history: %w", err)
 	}
 
 	// Iterate over history backwards
@@ -161,23 +158,23 @@ func GetWorkflowResult[T any](ctx context.Context, c Client, instance *workflow.
 		case history.EventType_WorkflowExecutionFinished:
 			a := event.Attributes.(*history.ExecutionCompletedAttributes)
 			if a.Error != "" {
-				return z, errors.New(a.Error)
+				return *new(T), errors.New(a.Error)
 			}
 
 			var r T
 			if err := converter.DefaultConverter.From(a.Result, &r); err != nil {
-				return z, fmt.Errorf("converting result: %w", err)
+				return *new(T), fmt.Errorf("converting result: %w", err)
 			}
 
 			return r, nil
 
 		case history.EventType_WorkflowExecutionCanceled:
-			return z, ErrWorkflowCanceled
+			return *new(T), ErrWorkflowCanceled
 
 		case history.EventType_WorkflowExecutionTerminated:
-			return z, ErrWorkflowTerminated
+			return *new(T), ErrWorkflowTerminated
 		}
 	}
 
-	return z, errors.New("workflow finished, but could not find result event")
+	return *new(T), errors.New("workflow finished, but could not find result event")
 }

internal/sync/channel.go

@@ -151,8 +151,7 @@ func (c *channel[T]) ReceiveNonBlocking(ctx Context) (T, bool) {
 		return v, ok
 	}
 
-	var z T
-	return z, false
+	return *new(T), false
 }
 
 func (c *channel[T]) hasValue() bool {
@@ -203,8 +202,7 @@ func (c *channel[T]) tryReceive() (v T, ok bool, rok bool) {
 	// If channel has been closed and no values in buffer (if buffered) return zero
 	// element
 	if c.closed {
-		var z T
-		return z, false, true
+		return *new(T), false, true
 	}
 
 	// Any blocked senders? If so, receive from the first one

internal/sync/future.go

@@ -57,8 +57,7 @@ func (f *future[T]) Get(ctx Context) (T, error) {
 			cr.MadeProgress()
 
 			if f.err != nil {
-				var zero T
-				return zero, f.err
+				return *new(T), f.err
 			}
 
 			return f.v, nil

internal/workflowstate/workflowstate.go

@@ -27,8 +27,7 @@ func AsDecodingSettable[T any](f sync.SettableFuture[T]) DecodingSettable {
 			converter.DefaultConverter.From(v, &t)
 			ferr = f.Set(t, err)
 		} else {
-			var z T
-			ferr = f.Set(z, err)
+			ferr = f.Set(*new(T), err)
 		}
 
 		return ferr

workflow/activity.go

@@ -31,8 +31,7 @@ func executeActivity[TResult any](ctx sync.Context, options ActivityOptions, act
 
 	inputs, err := a.ArgsToInputs(converter.DefaultConverter, args...)
 	if err != nil {
-		var z TResult
-		f.Set(z, fmt.Errorf("converting activity input: %w", err))
+		f.Set(*new(TResult), fmt.Errorf("converting activity input: %w", err))
 		return f
 	}
 
@@ -54,8 +53,7 @@ func executeActivity[TResult any](ctx sync.Context, options ActivityOptions, act
 
 					wfState.RemoveFuture(scheduleEventID)
 
-					var z TResult
-					f.Set(z, sync.Canceled)
+					f.Set(*new(TResult), sync.Canceled)
 				}
 			}
 		}

workflow/sideeffect.go

@@ -28,8 +28,7 @@ func SideEffect[TResult any](ctx sync.Context, f func(ctx sync.Context) TResult)
 	// Create command to add it to the history
 	payload, err := converter.DefaultConverter.To(r)
 	if err != nil {
-		var z TResult
-		future.Set(z, err)
+		future.Set(*new(TResult), err)
 	}
 
 	cmd := command.NewSideEffectCommand(scheduleEventID, payload)