code builder doc effort

src/builder/code.rs

@@ -2,11 +2,13 @@ use elements;
 use super::invoke::{Invoke, Identity};
 use super::misc::{ValueTypeBuilder, ValueTypesBuilder, OptionalValueTypeBuilder};
 
+/// Signature template description
 pub enum Signature {
     TypeReference(u32),
     Inline(elements::FunctionType),
 }
 
+/// Signature builder
 pub struct SignatureBuilder<F=Identity> {
     callback: F,
     signature: elements::FunctionType,
@@ -19,6 +21,7 @@ impl SignatureBuilder {
 }
 
 impl<F> SignatureBuilder<F> where F: Invoke<elements::FunctionType> {
+    /// New builder with callback function specified
     pub fn with_callback(callback: F) -> Self {
         SignatureBuilder {
             callback: callback,
@@ -26,37 +29,45 @@ impl<F> SignatureBuilder<F> where F: Invoke<elements::FunctionType> {
         }
     }
 
+    /// Add argument to signature builder
     pub fn with_param(mut self, value_type: elements::ValueType) -> Self {
         self.signature.params_mut().push(value_type);
         self
     }
 
+    /// Add multiple arguments to signature builder
     pub fn with_params(mut self, value_types: Vec<elements::ValueType>) -> Self {
         self.signature.params_mut().extend(value_types);
         self
     }
 
+    /// Override signature return type
     pub fn with_return_type(mut self, return_type: Option<elements::ValueType>) -> Self {
         *self.signature.return_type_mut() = return_type;
         self
     }
 
+    /// Start build new argument
     pub fn param(self) -> ValueTypeBuilder<Self> {
         ValueTypeBuilder::with_callback(self)
     }
 
+    /// Start build multiple arguments
     pub fn params(self) -> ValueTypesBuilder<Self> {
         ValueTypesBuilder::with_callback(self)
     }
 
+    /// Start building return type
     pub fn return_type(self) -> OptionalValueTypeBuilder<Self> {
         OptionalValueTypeBuilder::with_callback(self)
     }
 
+    /// Finish current builder
     pub fn build(self) -> F::Result {
         self.callback.invoke(self.signature)
     }
 
+    /// Finish current builder returning intermediate `Signature` struct
     pub fn build_sig(self) -> Signature {
         Signature::Inline(self.signature)
     }
@@ -92,12 +103,14 @@ impl<F> Invoke<elements::ValueType> for SignatureBuilder<F>
     }
 }
 
+/// Type (signature) reference builder (for function/import/indirect call)
 pub struct TypeRefBuilder<F=Identity> {
     callback: F,
     type_ref: u32,
 }
 
 impl<F> TypeRefBuilder<F> where F: Invoke<u32> {
+    /// New builder chained with specified callback
     pub fn with_callback(callback: F) -> Self {
         TypeRefBuilder {
             callback: callback,
@@ -105,14 +118,17 @@ impl<F> TypeRefBuilder<F> where F: Invoke<u32> {
         }
     }
 
+    /// Set/override of type reference
     pub fn val(mut self, val: u32) -> Self {
         self.type_ref = val;
         self
     }
 
+    /// Finish current builder
     pub fn build(self) -> F::Result { self.callback.invoke(self.type_ref) }
 }
 
+/// Multiple signatures builder
 pub struct SignaturesBuilder<F=Identity> {
     callback: F,
     section: Vec<Signature>,

src/builder/mod.rs

@@ -11,9 +11,12 @@ mod export;
 mod global;
 mod data;
 
+pub use self::code::{
+    signatures, signature, function, SignatureBuilder, SignaturesBuilder,
+    FunctionBuilder, TypeRefBuilder
+};
 pub use self::invoke::Identity;
 pub use self::module::{module, from_module, ModuleBuilder};
-pub use self::code::{signatures, signature, function, SignatureBuilder, FunctionBuilder};
 pub use self::memory::MemoryBuilder;
 pub use self::import::{import, ImportBuilder};
 pub use self::export::{export, ExportBuilder};