Add BytesOut and StringOut typed output wrappers

Avoid extra allocations by returning typed ClonedVar wrappers directly.
The macro detects these types and extracts the inner ClonedVar without
calling .into() on intermediate allocations.

Author: sinkingsugar

shards/modules/core/src/uuid.rs

@@ -7,11 +7,13 @@ use shards::shard::LegacyShard;
 use shards::shard::Shard;
 use shards::simple_shard;
 
+use shards::types::BytesOut;
 use shards::types::ClonedVar;
 use shards::types::Context;
 use shards::types::ExposedTypes;
 use shards::types::InstanceData;
 use shards::types::OptionalString;
+use shards::types::StringOut;
 use shards::types::BYTES_OR_STRING_TYPES;
 use shards::types::INT_TYPES;
 
@@ -38,28 +40,28 @@ fn uuid_to_string(
   input: [u8; 16],
   #[param("Hyphenated", "Whether to use hyphens in the output.", default = false)]
   hyphenated: bool,
-) -> String {
+) -> StringOut {
   let uuid = uuid::Uuid::from_bytes(input);
   if hyphenated {
-    uuid.hyphenated().to_string()
+    uuid.hyphenated().to_string().as_str().into()
   } else {
-    uuid.simple().to_string()
+    uuid.simple().to_string().as_str().into()
   }
 }
 
 #[simple_shard("UUID.ToBytes", "Reads a UUID and formats it into bytes.")]
-fn uuid_to_bytes(input: [u8; 16]) -> Vec<u8> {
-  input.to_vec()
+fn uuid_to_bytes(input: [u8; 16]) -> BytesOut {
+  input.as_slice().into()
 }
 
 #[simple_shard("NanoID", "Creates a random NanoID.")]
 fn nanoid_create(
   _: (),
   #[param("Size", "The output string length of the created NanoID.", default = 21i64)]
   size: i64,
-) -> String {
+) -> StringOut {
   let size = size as usize;
-  nanoid::nanoid!(size)
+  nanoid::nanoid!(size).as_str().into()
 }
 
 // Legacy shard for UUID.Convert (handles multiple input types)

shards/rust/src/types/common.rs

@@ -212,6 +212,54 @@ pub type RawString = SHString;
 #[derive(Default, Serialize, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ClonedVar(pub Var);
 
+/// Typed wrapper for bytes output - avoids extra allocations
+#[repr(transparent)]
+#[derive(Default)]
+pub struct BytesOut(pub ClonedVar);
+
+/// Typed wrapper for string output - avoids extra allocations
+#[repr(transparent)]
+#[derive(Default)]
+pub struct StringOut(pub ClonedVar);
+
+impl BytesOut {
+  pub fn new(data: &[u8]) -> Self {
+    BytesOut(Var::from(data).into())
+  }
+}
+
+impl From<&[u8]> for BytesOut {
+  fn from(v: &[u8]) -> Self {
+    BytesOut::new(v)
+  }
+}
+
+impl std::ops::Deref for BytesOut {
+  type Target = ClonedVar;
+  fn deref(&self) -> &Self::Target {
+    &self.0
+  }
+}
+
+impl StringOut {
+  pub fn new(s: &str) -> Self {
+    StringOut(Var::ephemeral_string(s).into())
+  }
+}
+
+impl From<&str> for StringOut {
+  fn from(v: &str) -> Self {
+    StringOut::new(v)
+  }
+}
+
+impl std::ops::Deref for StringOut {
+  type Target = ClonedVar;
+  fn deref(&self) -> &Self::Target {
+    &self.0
+  }
+}
+
 impl Ord for Var {
   fn cmp(&self, other: &Self) -> std::cmp::Ordering {
     unsafe {

shards/rust/src/types/shard_type.rs

@@ -161,3 +161,16 @@ impl ShardType for SHColor {
     fn shards_types() -> &'static Types { &COLOR_TYPES }
     fn shards_var_type() -> Type { common_type::color_var }
 }
+
+// Typed output wrappers
+impl ShardType for super::BytesOut {
+    fn shards_type() -> Type { common_type::bytes }
+    fn shards_types() -> &'static Types { &BYTES_TYPES }
+    fn shards_var_type() -> Type { common_type::bytes_var }
+}
+
+impl ShardType for super::StringOut {
+    fn shards_type() -> Type { common_type::string }
+    fn shards_types() -> &'static Types { &STRING_TYPES }
+    fn shards_var_type() -> Type { common_type::string_var }
+}

shards/rust_macro/src/lib.rs

@@ -1145,30 +1145,37 @@ fn generate_simple_shard(args: SimpleShardAttrArgs, func: syn::ItemFn) -> Result
 
   // Get output type from return type
   let mut returns_result = false;
+  let mut returns_typed_out = false; // BytesOut, StringOut, etc.
   let output_type = match &func.sig.output {
     syn::ReturnType::Type(_, ty) => {
       // Handle Result<T, _> wrapper
       if let syn::Type::Path(path) = ty.as_ref() {
-        if path
-          .path
-          .segments
-          .last()
-          .map(|s| s.ident == "Result")
-          .unwrap_or(false)
-        {
+        let type_name = path.path.segments.last().map(|s| s.ident.to_string());
+
+        if type_name.as_deref() == Some("Result") {
           returns_result = true;
           // Extract T from Result<T, E>
           if let syn::PathArguments::AngleBracketed(args) =
             &path.path.segments.last().unwrap().arguments
           {
             if let Some(syn::GenericArgument::Type(t)) = args.args.first() {
+              // Check if inner type is BytesOut/StringOut
+              if let syn::Type::Path(inner_path) = t {
+                let inner_name = inner_path.path.segments.last().map(|s| s.ident.to_string());
+                if matches!(inner_name.as_deref(), Some("BytesOut") | Some("StringOut")) {
+                  returns_typed_out = true;
+                }
+              }
               t.clone()
             } else {
               return Err("Invalid Result type".into());
             }
           } else {
             return Err("Invalid Result type".into());
           }
+        } else if matches!(type_name.as_deref(), Some("BytesOut") | Some("StringOut")) {
+          returns_typed_out = true;
+          ty.as_ref().clone()
         } else {
           ty.as_ref().clone()
         }
@@ -1259,7 +1266,7 @@ fn generate_simple_shard(args: SimpleShardAttrArgs, func: syn::ItemFn) -> Result
     .filter(|p| p.is_var)
     .map(|p| {
       let name = &p.rust_name;
-      quote! { self.#name.cleanup(Some(context)); }
+      quote! { self.#name.cleanup(context); }
     })
     .collect();
 
@@ -1382,6 +1389,13 @@ fn generate_simple_shard(args: SimpleShardAttrArgs, func: syn::ItemFn) -> Result
     },
   };
 
+  // Generate output assignment - typed outputs (BytesOut, StringOut) are already ClonedVar wrappers
+  let output_assignment = if returns_typed_out {
+    quote! { self.output = result.0; }
+  } else {
+    quote! { self.output = result.into(); }
+  };
+
   // Generate compose calls for param_var parameters
   let has_var_params = params.iter().any(|p| p.is_var);
   let param_var_composes: Vec<_> = params
@@ -1500,9 +1514,7 @@ fn generate_simple_shard(args: SimpleShardAttrArgs, func: syn::ItemFn) -> Result
       }
 
       fn cleanup(&mut self, context: std::option::Option<&shards::types::Context>) -> std::result::Result<(), &str> {
-        if let Some(context) = context {
-          #(#param_cleanups)*
-        }
+        #(#param_cleanups)*
         self.output = shards::types::ClonedVar::default();
         Ok(())
       }
@@ -1517,7 +1529,7 @@ fn generate_simple_shard(args: SimpleShardAttrArgs, func: syn::ItemFn) -> Result
         #(#param_extractions)*
 
         let result = #activate_call;
-        self.output = result.into();
+        #output_assignment
         Ok(Some(self.output.0))
       }
     }