fix: do not require reduce when there is only one impl

codegen/src/derive_fillers/derive_delegate.rs

@@ -318,23 +318,26 @@ fn transform_return(
 ) -> syn::Result<Vec<syn::Stmt>> {
     let exprs = transform_arg_fields(item, fn_args, trait_path, fields, ctor_path, is_refutable)?;
 
+    let exprs = match exprs.try_into() {
+        Ok::<[_; 1], _>([(single, _, _)]) => return Ok(vec![syn::Stmt::Expr(single, None)]),
+        Err(err) => err,
+    };
+
     Ok(match (&fn_args.reduce.0, output_ty) {
         (Some((_, reduce_fn)), _) => {
             let mut exprs_iter = exprs.into_iter();
 
-            let mut stack;
-
-            if let Some((_, reduce_base)) = &fn_args.reduce_base.0 {
-                stack = reduce_base.clone();
+            let mut stack = if let Some((_, reduce_base)) = &fn_args.reduce_base.0 {
+                reduce_base.clone()
             } else {
                 let Some((first, _, _)) = exprs_iter.next() else {
                     return Err(syn::Error::new(
                         Span::call_site(),
                         "derive_delegate(reduce) is not applicable for empty structs",
                     ));
                 };
-                stack = first;
-            }
+                first
+            };
 
             for (expr, _, field) in exprs_iter {
                 stack = syn::parse_quote_spanned! { field.span() =>
@@ -383,9 +386,9 @@ fn transform_return(
             return Err(syn::Error::new_spanned(
                 output_ty,
                 "Cannot determine how to aggregate the return value. Supported return types are \
-                 `()`, `Self` or arbitrary types with the `#[portrait(derive_delegate(reduce = \
-                 _))]` attribute, or `Option<>`/`Result<>` wrapping them with \
-                 `#[portrait(derive_delegate(with_try))]`.",
+                    `()`, `Self` or arbitrary types with the `#[portrait(derive_delegate(reduce = \
+                    _))]` attribute, or `Option<>`/`Result<>` wrapping them with \
+                    `#[portrait(derive_delegate(with_try))]`.",
             ))
         }
     })

tests/derive_delegate.rs

@@ -8,7 +8,7 @@ trait Foo {
 }
 
 #[portrait::fill(portrait::default)]
-impl Foo for i32 { }
+impl Foo for i32 {}
 
 #[portrait::fill(portrait::default)]
 impl Foo for String {}

tests/derive_delegate_single.rs

@@ -0,0 +1,22 @@
+#[portrait::make]
+trait Foo {
+    fn foo(&self, arg1: i32, arg2: &str, arg3: &mut i64) -> bool;
+}
+
+#[portrait::fill(portrait::default)]
+impl Foo for i32 {}
+
+#[portrait::fill(portrait::default)]
+impl Foo for String {}
+
+#[portrait::derive(Foo with portrait::derive_delegate)]
+enum Impls {
+    A(i32),
+    B(String),
+}
+
+fn main() {
+    fn assert(_: impl Foo) {}
+
+    assert(Impls::A(1));
+}