fix bug in reduce method

Author: EvandroLG

array.lua

@@ -202,14 +202,20 @@ array = {
   -- Applies a function against an accumulator and each value of the table to reduce it to a single value
   -- @obj {table}
   -- @callback {function}
-  -- @memo
+  -- @memo {*}
   -- @returns {*}
   reduce = function(obj, callback, memo)
     raises_error(array, obj, 'reduce')
 
-    local _memo = memo or 0
+    local initialIndex = 1
+    local _memo = memo
 
-    for i=1, #obj do
+    if _memo == nil then
+        initialIndex = 2
+        _memo = obj[1]
+    end
+
+    for i=initialIndex, #obj do
       _memo = callback(_memo, obj[i], i)
     end
 

test.lua

@@ -7,43 +7,43 @@ test('meta infos', function(a)
   "A small library with useful methods to handle Lua's table when it's working like an Array")
 end)
 
-test('is_array should returns false when object is not a table', function(a)
+test('is_array should return false when object is not a table', function(a)
   a.equal(array.is_array('lua'), false)
 end)
 
-test('is_array should returns false when the table is working like a dictionary', function(a)
+test('is_array should return false when the table is working like a dictionary', function(a)
   a.equal(array.is_array({ language='lua' }), false)
 end)
 
-test('is_array should returns true when table is empty', function(a)
+test('is_array should return true when table is empty', function(a)
   a.equal(array.is_array({}), true)
 end)
 
-test('is_array should returns true when table is working like an array', function(a)
+test('is_array should return true when table is working like an array', function(a)
   a.equal(array.is_array({ 'a', 'b', 'c', 'd' }), true)
 end)
 
-test('is_empty should returns false when table has at least one item', function(a)
+test('is_empty should return false when table has at least one item', function(a)
   a.equal(array.is_empty({ 'a' }), false)
 end)
 
-test('is_empty should returns false when table does not have any item', function(a)
+test('is_empty should return false when table does not have any item', function(a)
   a.equal(array.is_empty({}), true)
 end)
 
-test('first should returns first item from table', function(a)
+test('first should return first item from table', function(a)
   a.equal(array.first({ 'a', 'b', 'c', 'd' }), 'a')
 end)
 
-test('last should returns last item from table', function(a)
+test('last should return last item from table', function(a)
   a.equal(array.last({ 'a', 'b', 'c', 'd' }), 'd')
 end)
 
-test('slice should returns a empty table when it does not have any element', function(a)
+test('slice should return an empty table when it does not have any element', function(a)
   a.equal(#array.slice({}, 1, 2), 0)
 end)
 
-test('slice should returns a table with values between start index and end index', function(a)
+test('slice should return a table with values between start index and end index', function(a)
   local result = array.slice({ 'lua', 'javascript', 'python', 'ruby', 'c' }, 2, 4)
 
   a.equal(type(result), 'table')
@@ -53,7 +53,7 @@ test('slice should returns a table with values between start index and end index
   a.equal(result[3], 'ruby')
 end)
 
-test('slice should returns a table with every values from start index until last index', function(a)
+test('slice should return a table with every values from start index until last index', function(a)
   local result = array.slice({ 'lua', 'javascript', 'python', 'ruby', 'c' }, 2)
 
   a.equal(type(result), 'table')
@@ -64,7 +64,7 @@ test('slice should returns a table with every values from start index until last
   a.equal(result[4], 'c')
 end)
 
-test('reverse should returns an inverted table', function(a)
+test('reverse should return an inverted table', function(a)
   local result = array.reverse({ 'lua', 'javascript', 'python' })
 
   a.equal(type(result), 'table')
@@ -74,7 +74,7 @@ test('reverse should returns an inverted table', function(a)
   a.equal(result[3], 'lua')
 end)
 
-test('map should returns a table with 2, 4, 6 values', function(a)
+test('map should return a table with 2, 4, 6 values', function(a)
   local result = array.map({ 1, 2, 3 }, function(value)
     return value * 2
   end)
@@ -86,7 +86,7 @@ test('map should returns a table with 2, 4, 6 values', function(a)
   a.equal(result[3], 6)
 end)
 
-test('filter should returns a table with 10, 15, 20 values', function(a)
+test('filter should return a table with 10, 15, 20 values', function(a)
   local result = array.filter({ 15, 10, 5, 3, 20 }, function(value)
     return value >= 10
   end)
@@ -98,54 +98,70 @@ test('filter should returns a table with 10, 15, 20 values', function(a)
   a.equal(result[3], 20)
 end)
 
-test('max should returns the biggest value from a table', function(a)
+test('max should return the biggest value from a table', function(a)
   a.equal(array.max({ 20, 22, 1, 3, 30, 42 }), 42)
 end)
 
-test('max should returns nil when table is empty', function(a)
+test('max should return nil when table is empty', function(a)
   a.equal(array.max({}), nil)
 end)
 
-test('min should returns the smallest value from a table', function(a)
+test('min should return the smallest value from a table', function(a)
   a.equal(array.min({ 20, 22, 1, 3, 30, 42 }), 1)
 end)
 
-test('min should returns nil when table is empty', function(a)
+test('min should return nil when table is empty', function(a)
   a.equal(array.min({}), nil)
 end)
 
-test('reduce should returns 90', function(a)
+test('reduce should return 90', function(a)
   local result = array.reduce({ 20, 30, 40 }, function(memo, value)
     return memo + value
   end)
 
   a.equal(result, 90)
 end)
 
-test('reduce should returns 100', function(a)
+test('reduce should return 100', function(a)
   local result = array.reduce({ 20, 30, 40 }, function(memo, value)
     return memo + value
   end, 10)
 
   a.equal(result, 100)
 end)
 
-test('index_of should returns correct position of value in the table', function(a)
+test('reduce should return first item', function(a)
+  local result = array.reduce({ 20 }, function(memo, value)
+    return memo + value
+  end)
+
+  a.equal(result, 20)
+end)
+
+test('reduce should concatenate all items', function(a)
+  local result = array.reduce({ 'a', 'b', 'c', 'd', 'e' }, function(memo, value)
+    return memo .. value
+  end)
+
+  a.equal(result, 'abcde')
+end)
+
+test('index_of should return correct position of value in the table', function(a)
   a.equal(array.index_of({ 20, 30, 40, 50 }, 40), 3)
 end)
 
-test('index_of should returns -1 when the value is not in the table', function(a)
+test('index_of should return -1 when the value is not in the table', function(a)
   a.equal(array.index_of({ 20, 30, 40 }, 50), -1)
 end)
 
-test('concat should joins the two array', function(a)
+test('concat should join the two array', function(a)
   local result = array.concat({ 1, 2, 3 }, { 4, 5, 6 })
 
   a.equal(#result, 6)
   a.equal(result[4], 4)
 end)
 
-test('uniq should returns every value once', function(a)
+test('uniq should return every value once', function(a)
   local result = array.uniq({ 'a', 'b', 'a', 'b', 'c', 'd' })
 
   a.equal(#result, 4)
@@ -155,7 +171,7 @@ test('uniq should returns every value once', function(a)
   a.equal(result[4], 'd')
 end)
 
-test('without should returns all values less the items from second array', function(a)
+test('without should return all values less the items from second array', function(a)
   local result = array.without({ 10, 20, 30, 10, 4 }, { 10, 4 })
 
   a.equal(#result, 2)