refactor value types gen a bit

examples/build.rs

@@ -14,7 +14,7 @@ fn main() {
 
     let module = builder::module()
         .functions()
-            .signature().param(elements::ValueType::I32).build()
+            .signature().with_param(elements::ValueType::I32).build()
             .bind()
         .build();
 

src/builder/code.rs

@@ -1,5 +1,6 @@
-use super::invoke::{Invoke, Identity};
 use elements;
+use super::invoke::{Invoke, Identity};
+use super::misc::{ValueTypeBuilder, ValueTypesBuilder, OptionalValueTypeBuilder};
 
 pub enum Signature {
     TypeReference(u32),
@@ -19,22 +20,68 @@ impl<F> SignatureBuilder<F> where F: Invoke<elements::FunctionType> {
         }
     }
 
-    pub fn param(mut self, value_type: elements::ValueType) -> Self {
+    pub fn with_param(mut self, value_type: elements::ValueType) -> Self {
         self.signature.params_mut().push(value_type);
-
         self
     }
 
-    pub fn return_type(mut self, value_type: elements::ValueType) -> Self {
-        *self.signature.return_type_mut() = Some(value_type);                
+    pub fn with_params(mut self, value_types: Vec<elements::ValueType>) -> Self {
+        self.signature.params_mut().extend(value_types);
         self
     }
 
+    pub fn with_return_type(mut self, return_type: Option<elements::ValueType>) -> Self {
+        *self.signature.return_type_mut() = return_type;
+        self
+    }
+
+    pub fn param(self) -> ValueTypeBuilder<Self> {
+        ValueTypeBuilder::with_callback(self)
+    }
+
+    pub fn params(self) -> ValueTypesBuilder<Self> {
+        ValueTypesBuilder::with_callback(self)
+    }
+
+    pub fn return_type(self) -> OptionalValueTypeBuilder<Self> {
+        OptionalValueTypeBuilder::with_callback(self)
+    }
+
     pub fn build(self) -> F::Result {
         self.callback.invoke(self.signature)
     }
 }
 
+impl<F> Invoke<Vec<elements::ValueType>> for SignatureBuilder<F>
+    where F: Invoke<elements::FunctionType>
+{
+    type Result = Self;
+
+    fn invoke(self, args: Vec<elements::ValueType>) -> Self {
+        self.with_params(args)
+    }
+}
+
+impl<F> Invoke<Option<elements::ValueType>> for SignatureBuilder<F>
+    where F: Invoke<elements::FunctionType>
+{
+    type Result = Self;
+
+    fn invoke(self, arg: Option<elements::ValueType>) -> Self {
+        self.with_return_type(arg)
+    }
+}
+
+impl<F> Invoke<elements::ValueType> for SignatureBuilder<F> 
+    where F: Invoke<elements::FunctionType>  
+{
+    type Result = Self;
+
+    fn invoke(self, arg: elements::ValueType) -> Self {
+        self.with_param(arg)
+    }
+}
+
 pub struct TypeRefBuilder<F=Identity> {
     callback: F,
     type_ref: u32,
@@ -150,9 +197,9 @@ mod tests {
 
         let result = function()
             .signature()
-                .param(::elements::ValueType::I32)
-                .param(::elements::ValueType::I32)
-                .return_type(::elements::ValueType::I64)
+                .param().i32()
+                .param().i32()
+                .return_type().i64()
                 .build()
             .bind();      
 

src/builder/misc.rs

@@ -0,0 +1,93 @@
+use super::invoke::{Invoke, Identity};
+use elements;
+
+pub struct ValueTypeBuilder<F=Identity> {
+    callback: F,
+}
+
+impl<F> ValueTypeBuilder<F> where F: Invoke<elements::ValueType> {
+    pub fn with_callback(callback: F) -> Self {
+        ValueTypeBuilder { callback: callback }
+    }
+
+    pub fn i32(self) -> F::Result {
+        self.callback.invoke(elements::ValueType::I32)
+    }
+
+    pub fn i64(self) -> F::Result {
+        self.callback.invoke(elements::ValueType::I64)
+    }    
+
+    pub fn f32(self) -> F::Result {
+        self.callback.invoke(elements::ValueType::F32)
+    }
+
+    pub fn f64(self) -> F::Result {
+        self.callback.invoke(elements::ValueType::F64)
+    }
+}
+
+pub struct OptionalValueTypeBuilder<F=Identity> {
+    callback: F,
+}
+
+impl<F> OptionalValueTypeBuilder<F> where F: Invoke<Option<elements::ValueType>> {
+    pub fn with_callback(callback: F) -> Self {
+        OptionalValueTypeBuilder { callback: callback }
+    }
+
+    pub fn i32(self) -> F::Result {
+        self.callback.invoke(Some(elements::ValueType::I32))
+    }
+
+    pub fn i64(self) -> F::Result {
+        self.callback.invoke(Some(elements::ValueType::I64))
+    }    
+
+    pub fn f32(self) -> F::Result {
+        self.callback.invoke(Some(elements::ValueType::F32))
+    }
+
+    pub fn f64(self) -> F::Result {
+        self.callback.invoke(Some(elements::ValueType::F64))
+    }
+}
+
+pub struct ValueTypesBuilder<F=Identity> {
+    callback: F,
+    value_types: Vec<elements::ValueType>,
+}
+
+impl<F> ValueTypesBuilder<F> where F: Invoke<Vec<elements::ValueType>> {
+    pub fn with_callback(callback: F) -> Self {
+        ValueTypesBuilder {
+            callback: callback,
+            value_types: Vec::new(),
+        }
+    }
+
+    pub fn i32(mut self) -> Self {
+        self.value_types.push(elements::ValueType::I32);
+        self
+    }
+
+    pub fn i64(mut self) -> Self {
+        self.value_types.push(elements::ValueType::I64);
+        self
+    }    
+
+    pub fn f32(mut self) -> Self {
+        self.value_types.push(elements::ValueType::F32);
+        self
+    }
+
+    pub fn f64(mut self) -> Self {
+        self.value_types.push(elements::ValueType::F64);
+        self
+    }    
+
+    pub fn build(self) -> F::Result {
+        self.callback.invoke(self.value_types)
+    }
+}
+

src/builder/mod.rs

@@ -3,6 +3,7 @@
 mod invoke;
 mod module;
 mod code;
+mod misc;
 
 pub use self::module::{module, ModuleBuilder};
 pub use self::code::function;

src/builder/module.rs

@@ -162,7 +162,7 @@ mod tests {
     fn functions() {
         let module = module()
             .functions()
-                .signature().param(::elements::ValueType::I32).build()
+                .signature().with_param(::elements::ValueType::I32).build()
                 .bind()
             .build();