Merge pull request #3 from thecasualcoder/reduce

Add reduce function

Author: aswinkarthik

README.md

@@ -11,6 +11,7 @@ This library heavily makes use of `reflect` package and hence will have an **imp
 
 1. [Map](#Map)
 2. [Filter](#Filter)
+3. [Reduce](#Reduce)
 
 ## Usages
 
@@ -88,3 +89,45 @@ func main() {
 	fmt.Println(output) // prints {Doe 30}
 }
 ```
+
+### Reduce
+
+Reduce reduces the given collection using given reduce function 
+
+_Primitive types_
+
+```go
+func main() {
+	input := []int{1, 2, 3, 4, 5}
+	var output int
+
+	godash.Reduce(input, &output, func(sum, element int) int {
+		return sum + element
+	})
+
+	fmt.Println(output) // prints 15
+}
+```
+
+_Struct type_
+
+```go
+type Person struct {
+	Name string
+	Age Int
+}
+
+func main() {
+	input := []Person{
+		{Name: "John", Age: 22},
+		{Name: "Doe", Age: 23},
+	}
+	var output int
+
+	godash.Reduce(input, &output, func(sum int, person Person) int {
+		return sum + person.Age
+	})
+
+	fmt.Println(output) // prints 45
+}
+```

reduce.go

@@ -0,0 +1,71 @@
+package godash
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Reduce reduces the given collection using given reduce function
+func Reduce(in, out, reduceFn interface{}) error {
+	input := reflect.ValueOf(in)
+	output := reflect.ValueOf(out)
+	if err := isReferenceType(output); err != nil {
+		return err
+	}
+
+	reducer := reflect.ValueOf(reduceFn)
+	if err := validateReducer(reducer); err != nil {
+		return err
+	}
+
+	if input.Kind() == reflect.Slice {
+		outputKind := output.Elem().Kind()
+		reducerFnType := reducer.Type()
+		if outputKind != reducerFnType.In(0).Kind() {
+			return fmt.Errorf("reduceFn's first argument's type(%s) has to be the type of out(%s)", reducerFnType.In(0).Kind(), outputKind)
+		}
+		if input.Type().Elem().Kind() != reducerFnType.In(1).Kind() {
+			return fmt.Errorf("reduceFn's second argument's type(%s) has to be the type of element of input slice(%s)", reducerFnType.In(1).Kind(), input.Type().Elem().Kind())
+		}
+		if outputKind != reducerFnType.Out(0).Kind() {
+			return fmt.Errorf("reduceFn's return type(%s) has to be the type of out(%s)", reducerFnType.Out(0).Kind(), outputKind)
+		}
+
+		result := output.Elem()
+		for i := 0; i < input.Len(); i++ {
+			arg := input.Index(i)
+			returnValues := reducer.Call([]reflect.Value{result, arg})
+
+			result = returnValues[0]
+		}
+		output.Elem().Set(result)
+
+		return nil
+	}
+	return fmt.Errorf("not implemented")
+}
+
+func validateReducer(reducer reflect.Value) error {
+	reducerFnType := reducer.Type()
+	if reducer.Kind() != reflect.Func {
+		return fmt.Errorf("reduceFn has to be a (func) and not (%s)", reducer.Kind())
+	}
+	if reducerFnType.NumIn() != 2 {
+		return fmt.Errorf("reduceFn has to take exactly 2 arguments and not %d argument(s)", reducerFnType.NumIn())
+	}
+	if reducerFnType.NumOut() != 1 {
+		return fmt.Errorf("reduceFn should have only one return value and not %d return type(s)", reducerFnType.NumOut())
+	}
+	return nil
+}
+
+func isReferenceType(output reflect.Value) error {
+	zeroValue := reflect.Value{}
+	if output == zeroValue {
+		return fmt.Errorf("output is nil. Pass a reference to set output")
+	}
+	if output.Kind() != reflect.Ptr {
+		return fmt.Errorf("cannot set out. Pass a reference to set output")
+	}
+	return nil
+}

reduce_test.go

@@ -0,0 +1,180 @@
+package godash_test
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/thecasualcoder/godash"
+	"strconv"
+	"testing"
+)
+
+func TestReduce(t *testing.T) {
+	t.Run("support primitive types", func(t *testing.T) {
+		{
+			in := []int{1, 2, 3}
+			var out int
+
+			err := godash.Reduce(in, &out, func(acc, element int) int {
+				return acc + element
+			})
+
+			expected := 6
+			assert.NoError(t, err)
+			assert.Equal(t, expected, out)
+		}
+		{
+			in := []int{1, 2, 3}
+			var out string
+
+			err := godash.Reduce(in, &out, func(acc string, element int) string {
+				return acc + strconv.Itoa(element)
+			})
+
+			expected := "123"
+			assert.NoError(t, err)
+			assert.Equal(t, expected, out)
+		}
+		{
+			in := []string{"one", "two", "two", "three", "three", "three"}
+			out := map[string]int{}
+
+			err := godash.Reduce(in, &out, func(acc map[string]int, element string) map[string]int {
+				if _, present := acc[element]; present {
+					acc[element] = acc[element] + 1
+				} else {
+					acc[element] = 1
+				}
+				return acc
+			})
+
+			expected := map[string]int{"one": 1, "two": 2, "three": 3}
+			assert.NoError(t, err)
+			assert.Equal(t, expected, out)
+		}
+	})
+
+	t.Run("support structs", func(t *testing.T) {
+		type person struct {
+			name string
+			age  int
+		}
+
+		in := []person{
+			{name: "john", age: 20},
+			{name: "doe", age: 23},
+		}
+		out := 0
+		expected := 43
+
+		err := godash.Reduce(in, &out, func(acc int, p person) int {
+			return acc + p.age
+		})
+
+		assert.NoError(t, err)
+		assert.Equal(t, expected, out)
+	})
+
+	add := func(acc, element int) int {
+		return acc + element
+	}
+
+	t.Run("should not panic if output is nil", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		{
+			var out int
+
+			err := godash.Reduce(in, out, add)
+
+			assert.EqualError(t, err, "cannot set out. Pass a reference to set output")
+		}
+
+		{
+			err := godash.Reduce(in, nil, add)
+
+			assert.EqualError(t, err, "output is nil. Pass a reference to set output")
+		}
+	})
+
+	t.Run("should not accept reducer function that are not functions", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out int
+
+		err := godash.Reduce(in, &out, 7)
+
+		assert.EqualError(t, err, "reduceFn has to be a (func) and not (int)")
+	})
+
+	t.Run("should not accept reducer function that do not take exactly two argument", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out int
+
+		{
+			err := godash.Reduce(in, &out, func() int { return 0 })
+			assert.EqualError(t, err, "reduceFn has to take exactly 2 arguments and not 0 argument(s)")
+		}
+
+		{
+			err := godash.Reduce(in, &out, func(int) int { return 0 })
+			assert.EqualError(t, err, "reduceFn has to take exactly 2 arguments and not 1 argument(s)")
+		}
+	})
+
+	t.Run("should not accept reducer function that do not return exactly one value", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out int
+
+		{
+			err := godash.Reduce(in, &out, func(int, int) {})
+			assert.EqualError(t, err, "reduceFn should have only one return value and not 0 return type(s)")
+		}
+
+		{
+			err := godash.Reduce(in, &out, func(int, int) (int, int) { return 0, 0 })
+			assert.EqualError(t, err, "reduceFn should have only one return value and not 2 return type(s)")
+		}
+	})
+
+	t.Run("should accept reducer function whose first argument's kind should be output's kind", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out int
+
+		{
+			err := godash.Reduce(in, &out, func(string, int) int { return 0 })
+			assert.EqualError(t, err, "reduceFn's first argument's type(string) has to be the type of out(int)")
+		}
+
+		{
+			err := godash.Reduce(in, &out, func(int, int) int { return 0 })
+			assert.NoError(t, err)
+		}
+	})
+
+	t.Run("should accept reducer function whose second argument's kind should be input slice's element kind", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out string
+
+		{
+			err := godash.Reduce(in, &out, func(string, string) string { return "" })
+			assert.EqualError(t, err, "reduceFn's second argument's type(string) has to be the type of element of input slice(int)")
+		}
+
+		{
+			err := godash.Reduce(in, &out, func(string, int) string { return "" })
+			assert.NoError(t, err)
+		}
+	})
+
+	t.Run("should accept reducer function whose return kind should be output's kind", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out string
+
+		{
+			err := godash.Reduce(in, &out, func(string, int) int { return 0 })
+			assert.EqualError(t, err, "reduceFn's return type(int) has to be the type of out(string)")
+		}
+
+		{
+			err := godash.Reduce(in, &out, func(string, int) string { return "" })
+			assert.NoError(t, err)
+		}
+	})
+}