diff --git a/dist/dust-helpers-1.0.0.js b/dist/dust-helpers-1.0.0.js
index c170b62..913b45e 100644
--- a/dist/dust-helpers-1.0.0.js
+++ b/dist/dust-helpers-1.0.0.js
@@ -14,7 +14,7 @@ if (typeof exports !== "undefined")
 
 /* make a safe version of console if it is not available
  * currently supporting:
- *   _console.log 
+ *   _console.log
  * */
 var _console = (typeof console !== 'undefined')? console: {
   log: function(){
@@ -24,12 +24,12 @@ var _console = (typeof console !== 'undefined')? console: {
 
 function isSelect(context) {
   var value = context.current();
-  return typeof value === "object" && value.isSelect === true;    
+  return typeof value === "object" && value.isSelect === true;
 }
 
 function filter(chunk, context, bodies, params, filter) {
   var params = params || {},
-      actual, 
+      actual,
       expected;
   if (params.key) {
     actual = helpers.tap(params.key, chunk, context);
@@ -82,7 +82,7 @@ var helpers = {
   },
   
   contextDump: function(chunk, context, bodies) {
-    _console.log(JSON.stringify(context.stack));
+    _console.log(JSON.stringify(context.stack.head));
     return chunk;
   },
   
@@ -92,20 +92,24 @@ var helpers = {
     var output = input;
     // dust compiles a string to function, if there are references
     if( typeof input === "function"){
-      output = '';
-      chunk.tap(function(data){
-        output += data;
-        return '';
-      }).render(input, context).untap();
-      if( output === '' ){
-        output = false;
+      if( ( typeof input.isReference !== "undefined" ) && ( input.isReference === true ) ){ // just a plain function, not a dust `body` function
+        output = input();
+      } else {
+        output = '';
+        chunk.tap(function(data){
+          output += data;
+          return '';
+        }).render(input, context).untap();
+        if( output === '' ){
+          output = false;
+        }
       }
-    } 
+    }
     return output;
   },
 
   /**
-  if helper 
+  if helper
    @param cond, either a string literal value or a dust reference
                 a string literal value, is enclosed in double quotes, e.g. cond="2>3"
                 a dust reference is also enclosed in double quotes, e.g. cond="'{val}'' > 3"
@@ -131,8 +135,72 @@ var helpers = {
     return chunk;
   },
   
+  /**
+   * math helper
+   * @param key is the value to perform math against
+   * @param eq is the value to test for equality with key
+   * @param method is the math method we will employ
+   * in the absence of an equality test
+   * @param operand is the second value needed for
+   * operations like mod, add, subtract, etc.
+   */
+  "math": function ( chunk, context, bodies, params ) {
+    //make sure we have key and eq or method params before continuing
+    if( params && params.key && (params.eq ||  params.method) ){
+      var key  = params.key;
+      key  = this.tap(key, chunk, context);
+      if (params.eq) {
+        var eq = params.eq;
+        eq = this.tap(eq, chunk, context);
+        return chunk.write(key === eq);
+      }
+      //we are going to operate with math methods if not equals
+      else {
+        var method = params.method;
+        var operand = params.operand || null;
+        var operError = function(){_console.log("operand is required for this math method")};
+        var returnExpression = function(exp){chunk.write( exp )};
+        if (operand) {
+          operand = this.tap(operand, chunk, context);
+        }
+        switch(method) {
+            case "mod":
+              (operand) ? returnExpression( parseFloat(key) % parseFloat(operand) ) : operError();
+              break;
+            case "add":
+              (operand) ? returnExpression( parseFloat(key) + parseFloat(operand) ) : operError();
+              break;
+            case "subtract":
+              (operand) ? returnExpression( parseFloat(key) - parseFloat(operand) ) : operError();
+              break;
+            case "multiply":
+              (operand) ? returnExpression( parseFloat(key) * parseFloat(operand) ) : operError();
+              break;
+            case "divide":
+              (operand) ? returnExpression( parseFloat(key) / parseFloat(operand) ) : operError();
+              break;
+            case "ceil":
+              returnExpression( Math.ceil(parseFloat(key)) );
+              break;
+            case "floor":
+              returnExpression( Math.floor(parseFloat(key)) );
+              break;
+            case "abs":
+              returnExpression( Math.abs(parseFloat(key)) );
+              break;
+            default:
+              _console.log( "method passed is not supported" );
+        }
+      }
+    }
+    // no key parameter and no method or eq passed
+    else {
+      _console.log( "Key is a required parameter along with eq or method/operand!" );
+    }
+    return chunk;
+  },
    /**
-   select/eq/lt/lte/gt/gte/default helper 
+   select/eq/lt/lte/gt/gte/default helper
    @param key, either a string literal value or a dust reference
                 a string literal value, is enclosed in double quotes, e.g. key="foo"
                 a dust reference may or may not be enclosed in double quotes, e.g. key="{val}" and key=val are both valid
@@ -174,28 +242,32 @@ var helpers = {
   "default": function(chunk, context, bodies, params) {
     return filter(chunk, context, bodies, params, function(expected, actual) { return true; });
   },
-
   "size": function( chunk, context, bodies, params ) {
-    var subject = params.subject; 
+    var subject = params.subject;
     var value   = 0;
     if (!subject) { //undefined, "", 0
-      value = 0;  
-    } else if(dust.isArray(subject)) { //array 
-      value = subject.length;  
-    } else if (!isNaN(subject)) { //numeric values  
-      value = subject;  
-    } else if (Object(subject) === subject) { //object test
-      var nr = 0;  
-      for(var k in subject) if(Object.hasOwnProperty.call(subject,k)) nr++;  
-        value = nr;
-    } else { 
-      value = (subject + '').length; //any other value (strings etc.)  
-    } 
-    return chunk.write(value); 
+      value = 0;
+    }
+    else if(dust.isArray(subject)) { //array
+      value = subject.length;
+    }
+    else if (!isNaN(subject)) { //numeric values
+      value = subject;
+    }
+    else if (Object(subject) === subject) { //object test
+      var nr = 0;
+      for(var k in subject)
+        if(Object.hasOwnProperty.call(subject,k)) nr++;
+          value = nr;
+    } else {
+      value = (subject + '').length; //any other value (strings etc.)
+    }
+    return chunk.write(value);
   }
 };
 
 dust.helpers = helpers;
+
 if (typeof exports !== "undefined")
 {
   module.exports = dust;
diff --git a/lib/dust-helpers.js b/lib/dust-helpers.js
index d36d544..1b7bbb9 100644
--- a/lib/dust-helpers.js
+++ b/lib/dust-helpers.js
@@ -75,7 +75,7 @@ var helpers = {
   },
   
   contextDump: function(chunk, context, bodies) {
-    _console.log(JSON.stringify(context.stack));
+    _console.log(JSON.stringify(context.stack.head));
     return chunk;
   },
   
@@ -85,7 +85,7 @@ var helpers = {
     var output = input;
     // dust compiles a string to function, if there are references
     if( typeof input === "function"){
-      if( input.length == 0 ) { // just a plain function, not a dust `body` function
+      if( ( typeof input.isReference !== "undefined" ) && ( input.isReference === true ) ){ // just a plain function, not a dust `body` function
         output = input();
       } else {
         output = '';
@@ -128,6 +128,70 @@ var helpers = {
     return chunk;
   },
   
+  /**
+   * math helper
+   * @param key is the value to perform math against
+   * @param eq is the value to test for equality with key
+   * @param method is the math method we will employ
+   * in the absence of an equality test
+   * @param operand is the second value needed for
+   * operations like mod, add, subtract, etc.
+   */
+  "math": function ( chunk, context, bodies, params ) {
+    //make sure we have key and eq or method params before continuing
+    if( params && params.key && (params.eq ||  params.method) ){
+      var key  = params.key;
+      key  = this.tap(key, chunk, context);
+      if (params.eq) {
+        var eq = params.eq;
+        eq = this.tap(eq, chunk, context);
+        return chunk.write(key === eq);
+      }
+      //we are going to operate with math methods if not equals
+      else {
+        var method = params.method;
+        var operand = params.operand || null;
+        var operError = function(){_console.log("operand is required for this math method")};
+        var returnExpression = function(exp){chunk.write( exp )};
+        if (operand) {
+          operand = this.tap(operand, chunk, context);
+        }
+        switch(method) {
+            case "mod":
+              (operand) ? returnExpression( parseFloat(key) % parseFloat(operand) ) : operError();
+              break;
+            case "add":
+              (operand) ? returnExpression( parseFloat(key) + parseFloat(operand) ) : operError();
+              break;
+            case "subtract":
+              (operand) ? returnExpression( parseFloat(key) - parseFloat(operand) ) : operError();
+              break;
+            case "multiply":
+              (operand) ? returnExpression( parseFloat(key) * parseFloat(operand) ) : operError();
+              break;
+            case "divide":
+              (operand) ? returnExpression( parseFloat(key) / parseFloat(operand) ) : operError();
+              break;
+            case "ceil":
+              returnExpression( Math.ceil(parseFloat(key)) );
+              break;
+            case "floor":
+              returnExpression( Math.floor(parseFloat(key)) );
+              break;
+            case "abs":
+              returnExpression( Math.abs(parseFloat(key)) );
+              break;
+            default:
+              _console.log( "method passed is not supported" );
+        }
+      }
+    }
+    // no key parameter and no method or eq passed
+    else {
+      _console.log( "Key is a required parameter along with eq or method/operand!" );
+    }
+    return chunk;
+  },
    /**
    select/eq/lt/lte/gt/gte/default helper
    @param key, either a string literal value or a dust reference
@@ -171,28 +235,32 @@ var helpers = {
   "default": function(chunk, context, bodies, params) {
     return filter(chunk, context, bodies, params, function(expected, actual) { return true; });
   },
-
   "size": function( chunk, context, bodies, params ) {
-    var subject = params.subject; 
+    var subject = params.subject;
     var value   = 0;
     if (!subject) { //undefined, "", 0
-      value = 0;  
-    } else if(dust.isArray(subject)) { //array 
-      value = subject.length;  
-    } else if (!isNaN(subject)) { //numeric values  
-      value = subject;  
-    } else if (Object(subject) === subject) { //object test
-      var nr = 0;  
-      for(var k in subject) if(Object.hasOwnProperty.call(subject,k)) nr++;  
-        value = nr;
-    } else { 
-      value = (subject + '').length; //any other value (strings etc.)  
-    } 
-    return chunk.write(value); 
+      value = 0;
+    }
+    else if(dust.isArray(subject)) { //array
+      value = subject.length;
+    }
+    else if (!isNaN(subject)) { //numeric values
+      value = subject;
+    }
+    else if (Object(subject) === subject) { //object test
+      var nr = 0;
+      for(var k in subject)
+        if(Object.hasOwnProperty.call(subject,k)) nr++;
+          value = nr;
+    } else {
+      value = (subject + '').length; //any other value (strings etc.)
+    }
+    return chunk.write(value);
   }
 };
 
 dust.helpers = helpers;
+
 if (typeof exports !== "undefined")
 {
   module.exports = dust;
diff --git a/test/jasmine-test/client/lib/.DS_Store b/test/jasmine-test/client/lib/.DS_Store
deleted file mode 100644
index 58e8be0..0000000
Binary files a/test/jasmine-test/client/lib/.DS_Store and /dev/null differ
diff --git a/test/jasmine-test/client/specRunner.html b/test/jasmine-test/client/specRunner.html
index 98b5ea4..ca0e3ce 100644
--- a/test/jasmine-test/client/specRunner.html
+++ b/test/jasmine-test/client/specRunner.html
@@ -20,6 +20,12 @@
 
   <script type="text/javascript">
     (function() {
+      //Add the tapper helper to test the Tap helper.
+      dust.helpers.tapper = function(chunk, context, bodies, params) {
+        var result = dust.helpers.tap(params.value,chunk,context);
+        chunk.write(result);
+        return chunk;
+      };
       var jasmineEnv = jasmine.getEnv();
       jasmineEnv.updateInterval = 1000;
 
diff --git a/test/jasmine-test/server/specRunner.js b/test/jasmine-test/server/specRunner.js
index fc51158..fe549f5 100644
--- a/test/jasmine-test/server/specRunner.js
+++ b/test/jasmine-test/server/specRunner.js
@@ -7,6 +7,13 @@ dust = require('dustjs-linkedin'),
 dust.helpers = require("../../../lib/dust-helpers").helpers,
 helpersTests = require('../spec/helpersTests');
 
+//Add the tapper helper to test the Tap helper.
+dust.helpers.tapper = function(chunk, context, bodies, params) {
+  var result = dust.helpers.tap(params.value,chunk,context);
+  chunk.write(result);
+  return chunk;
+};
+
 //Add the tapper helper to test the Tap helper.
 dust.helpers.tapper = function(chunk, context, bodies, params) {
   var result = dust.helpers.tap(params.value,chunk,context); 
diff --git a/test/jasmine-test/spec/helpersTests.js b/test/jasmine-test/spec/helpersTests.js
index 951898b..b6af7df 100644
--- a/test/jasmine-test/spec/helpersTests.js
+++ b/test/jasmine-test/spec/helpersTests.js
@@ -41,6 +41,83 @@ var helpersTests = [
     expected: "<div>bar</div>",
     message: "should test the if helper using $idx"
   },
+  {
+    name:     "math helper mod numbers",
+    source:   '<div>{@math key="16" method="mod" operand="4"/}</div>',  
+    context:  {},
+    expected: "<div>0</div>",
+    message: "testing math/mod helper with two numbers"
+  },
+  {
+    name:     "math helper mod using $idx",
+    source:   '{#list}<div>{@math key="{$idx}" method="mod" operand="5"/}</div>{/list}',
+    context:  { list: [ { y: 'foo' } ]},
+    expected: "<div>0</div>",
+    message: "should test the math/mod helper using $idx"
+  },
+  {
+    name:     "math helper subtract numbers",
+    source:   '<div>{@math key="16" method="subtract" operand="4"/}</div>',
+    context:  {},
+    expected: "<div>12</div>",
+    message: "testing math/subtract helper with two numbers"
+  },
+  {
+    name:     "math helper subtract number and string",
+    source:   '<div>{@math key="16" method="subtract" operand="doh"/}</div>',
+    context:  {},
+    expected: "<div>NaN</div>",
+    message: "testing math/subtract helper with a number and a string"
+  },
+  {
+    name:     "math helper add numbers",
+    source:   '<div>{@math key="5" method="add" operand="4"/}</div>',
+    context:  {},
+    expected: "<div>9</div>",
+    message: "testing math/add helper with two numbers"
+  },
+  {
+    name:     "math helper multiply numbers",
+    source:   '<div>{@math key="5" method="multiply" operand="4"/}</div>',
+    context:  {},
+    expected: "<div>20</div>",
+    message: "testing math/multiply helper with two numbers"
+  },
+  {
+    name:     "math helper divide using variable",
+    source:   '<div>{@math key="16" method="divide" operand="{y}"/}</div>',
+    context:  { y : 4 },
+    expected: "<div>4</div>",
+    message: "testing math/divide helper with variable as operand"
+  },
+  {
+    name:     "math helper floor numbers",
+    source:   '<div>{@math key="16.5" method="floor"/}</div>',
+    context:  {},
+    expected: "<div>16</div>",
+    message: "testing math/floor helper with two numbers"
+  },
+  {
+    name:     "math helper ceil numbers",
+    source:   '<div>{@math key="16.5" method="ceil"/}</div>',
+    context:  {},
+    expected: "<div>17</div>",
+    message: "testing math/ceil helper with two numbers"
+  },
+  {
+    name:     "math helper abs numbers",
+    source:   '<div>{@math key="-16" method="abs"/}</div>',
+    context:  {},
+    expected: "<div>16</div>",
+    message: "testing math/abs helper with two numbers"
+  },
+  { 
+    name:     "math helper eq  numbers",
+    source:   '<div>{@math key="15" eq="16"/}</div>',
+    context:  {},
+    expected: "<div>false</div>",
+    message: "testing math/eq helper with two numbers"
+  },
   {
     name:     "select helper with a constant string and condition eq",
     source:   ["{@select key=\"foo\"}",
@@ -398,6 +475,62 @@ var helpersTests = [
     context:  { "a" : {"foo" : function() { return "bar"; } } },
     expected: "bar bar",
     message: "should test if tap Helper is working properly when it makes reference to a function within an object-valued {context variable}"
+  },
+  {
+     name:     "array: reference $idx in iteration on objects",
+     source:   "{#names}({$idx}).{title} {name}{~n}{/names}",
+     context:  { title: "Sir", names: [ { name: "Moe" }, { name: "Larry" }, { name: "Curly" } ] },
+     expected: "(0).Sir Moe\n(1).Sir Larry\n(2).Sir Curly\n",
+     message: "array: reference $idx in iteration on objects"
+  },
+  {
+      name:     "array: reference $len in iteration on objects",
+      source:   "{#names}Size=({$len}).{title} {name}{~n}{/names}",
+      context:  { title: "Sir", names: [ { name: "Moe" }, { name: "Larry" }, { name: "Curly" } ] },
+      expected: "Size=(3).Sir Moe\nSize=(3).Sir Larry\nSize=(3).Sir Curly\n",
+      message: "test array: reference $len in iteration on objects"
+  },
+  {
+     name:     "array reference $idx in iteration on simple type",
+     source:   "{#names}({$idx}).{title} {.}{~n}{/names}",
+     context:  { title: "Sir", names: [ "Moe", "Larry", "Curly" ] },
+     expected: "(0).Sir Moe\n(1).Sir Larry\n(2).Sir Curly\n",
+     message: "test array reference $idx in iteration on simple types"
+  },
+  {
+      name:     "array reference $len in iteration on simple type",
+      source:   "{#names}Size=({$len}).{title} {.}{~n}{/names}",
+      context:  { title: "Sir", names: [ "Moe", "Larry", "Curly" ] },
+      expected: "Size=(3).Sir Moe\nSize=(3).Sir Larry\nSize=(3).Sir Curly\n",
+      message: "test array reference $len in iteration on simple types"
+  },
+  {
+      name:     "array reference $idx/$len on empty array case",
+      source:   "{#names}Idx={$idx} Size=({$len}).{title} {.}{~n}{/names}",
+      context:  { title: "Sir", names: [ ] },
+      expected: "",
+      message: "test array reference $idx/$len on empty array case"
+  },
+  {
+      name:     "array reference $idx/$len on single element case",
+      source:   "{#names}Idx={$idx} Size={$len} {.}{/names}",
+      context:  { names: "Just one name" },
+      expected: "Idx=0 Size=1 Just one name",
+      message: "test array reference $idx/$len on single element case"
+  },
+  {
+      name:     "array reference $idx/$len {#.} section case",
+      source:   "{#names}{#.}{$idx}{.} {/.}{/names}",
+      context:  { names:  ["Moe", "Larry", "Curly"] },
+      expected: "0Moe 1Larry 2Curly ",
+      message: "test array reference $idx/$len {#.} section case"
+  },
+  {
+      name:     "array reference $idx/$len nested loops",
+      source:   "{#A}A loop:{$idx}-{$len},{#B}B loop:{$idx}-{$len}C[0]={.C[0]} {/B}A loop trailing: {$idx}-{$len}{/A}",
+      context:  {"A": [ {"B": [ {"C": ["Ca1", "C2"]}, {"C": ["Ca2", "Ca22"]} ] }, {"B": [ {"C": ["Cb1", "C2"]}, {"C": ["Cb2", "Ca2"]} ] } ] },
+      expected: "A loop:0-2,B loop:0-2C[0]=Ca1 B loop:1-2C[0]=Ca2 A loop trailing: 0-2A loop:1-2,B loop:0-2C[0]=Cb1 B loop:1-2C[0]=Cb2 A loop trailing: 1-2",
+      message: "test array reference $idx/$len nested loops"
   }
 ];
 
diff --git a/test/server.js b/test/server.js
index 137b254..9e3fb52 100644
--- a/test/server.js
+++ b/test/server.js
@@ -3,6 +3,13 @@ var uutest    = require('./uutest'),
     tests     = require('./jasmine-test/spec/helpersTests'),
     coreSetup = require('./core').coreSetup;
 
+//Add the tapper helper to test the Tap helper.
+dust.helpers.tapper = function(chunk, context, bodies, params) {
+  var result = dust.helpers.tap(params.value,chunk,context);
+  chunk.write(result);
+  return chunk;
+};
+
 function dumpError(err) {
   var out = err.testName + " -> ";
   if (!err.message) {