Add filter function

Author: aswinkarthik

common.go

@@ -0,0 +1,24 @@
+package godash
+
+import (
+	"fmt"
+	"reflect"
+)
+
+
+func validateOut(output reflect.Value) error {
+	zeroValue := reflect.Value{}
+	if output == zeroValue {
+		return fmt.Errorf("output is nil. Pass a reference to set output")
+	}
+
+	if output.IsNil() {
+		return fmt.Errorf("output is nil. Pass a reference to set output")
+	}
+
+	if !output.Elem().CanSet() {
+		return fmt.Errorf("cannot set out. Pass a reference to set output")
+	}
+
+	return nil
+}

filter.go

@@ -0,0 +1,54 @@
+package godash
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func Filter(in, out, predicateFn interface{}) error {
+	input := reflect.ValueOf(in)
+
+	output := reflect.ValueOf(out)
+	if err := validateOut(output); err != nil {
+		return err
+	}
+	if input.Type() != output.Elem().Type() {
+		return fmt.Errorf("input(%s) and output(%s) should be of the same Type", input.Type(), output.Elem().Type())
+	}
+
+	predicate := reflect.ValueOf(predicateFn)
+	if predicate.Type().NumOut() != 1 {
+		return fmt.Errorf("predicate function should return only one return value - a boolean")
+	}
+	if predicateType := predicate.Type().Out(0).Kind(); predicateType != reflect.Bool {
+		return fmt.Errorf("predicate function should return only a (boolean) and not a (%s)", predicateType)
+	}
+
+	if input.Kind() == reflect.Slice {
+		{
+			if input.Type().Elem().Kind() != predicate.Type().In(0).Kind() {
+				return fmt.Errorf(
+					"predicate function's first argument has to be the type (%s) instead of (%s)",
+					input.Type().Elem(),
+					predicate.Type().In(0),
+				)
+			}
+		}
+
+		result := reflect.MakeSlice(output.Elem().Type(), 0, input.Len())
+		for i := 0; i < input.Len(); i++ {
+			arg := input.Index(i)
+
+			returnValues := predicate.Call([]reflect.Value{arg})
+			predicatePassed := returnValues[0].Bool()
+
+			if predicatePassed {
+				result = reflect.Append(result, arg)
+			}
+		}
+		output.Elem().Set(result)
+
+		return nil
+	}
+	return fmt.Errorf("not implemented")
+}

filter_test.go

@@ -0,0 +1,103 @@
+package godash_test
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/thecasualcoder/godash"
+	"testing"
+)
+
+func TestFilter(t *testing.T) {
+	t.Run("should filter elements that fail predicate", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5, 6, 7, 8}
+		var output []int
+
+		err := godash.Filter(input, &output, func(a int) bool {
+			return a%2 == 0
+		})
+		expected := []int{2, 4, 6, 8}
+
+		assert.NoError(t, err)
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("should struct types", func(t *testing.T) {
+		type person struct {
+			name string
+			age  int
+		}
+		input := []person{
+			{"john", 30},
+			{"doe", 20},
+			{"foo", 40},
+			{"bar", 10},
+		}
+		var output []person
+
+		err := godash.Filter(input, &output, func(p person) bool {
+			return p.age > 20
+		})
+		expected := []person{
+			{"john", 30},
+			{"foo", 40},
+		}
+
+		assert.NoError(t, err)
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("should validate predicate's arg", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5, 6, 7, 8}
+		var output []int
+
+		err := godash.Filter(input, &output, func(a string) bool {
+			return a == ""
+		})
+
+		assert.EqualError(t, err, "predicate function's first argument has to be the type (int) instead of (string)")
+	})
+
+	t.Run("should validate predicate's return type", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5, 6, 7, 8}
+		var output []int
+
+		{
+			err := godash.Filter(input, &output, func(a int) int {
+				return a
+			})
+			assert.EqualError(t, err, "predicate function should return only a (boolean) and not a (int)")
+		}
+		{
+			err := godash.Filter(input, &output, func(int) (int, bool) {
+				return 1, true
+			})
+			assert.EqualError(t, err, "predicate function should return only one return value - a boolean")
+		}
+	})
+
+	t.Run("should validate output's type", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5, 6, 7, 8}
+		var output []string
+
+		err := godash.Filter(input, &output, func(a int) bool {
+			return a == 0
+		})
+
+		assert.EqualError(t, err, "input([]int) and output([]string) should be of the same Type")
+	})
+
+	t.Run("should not panic if output is nil", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		{
+			var out []int
+
+			err := godash.Filter(in, out, func(int) bool { return true })
+
+			assert.EqualError(t, err, "output is nil. Pass a reference to set output")
+		}
+		{
+			err := godash.Filter(in, nil, func(int) bool { return true })
+
+			assert.EqualError(t, err, "output is nil. Pass a reference to set output")
+		}
+	})
+}

map.go

@@ -9,7 +9,7 @@ import (
 func Map(in, out, mapperFn interface{}) error {
 	input := reflect.ValueOf(in)
 	output := reflect.ValueOf(out)
-	if err := validateMapperOut(output); err != nil {
+	if err := validateOut(output); err != nil {
 		return err
 	}
 
@@ -38,22 +38,6 @@ func Map(in, out, mapperFn interface{}) error {
 	return fmt.Errorf("not implemented")
 }
 
-func validateMapperOut(output reflect.Value) error {
-	zeroValue := reflect.Value{}
-	if output == zeroValue {
-		return fmt.Errorf("output is nil. Pass a reference to set output")
-	}
-
-	if output.IsNil() {
-		return fmt.Errorf("output is nil. Pass a reference to set output")
-	}
-
-	if !output.Elem().CanSet() {
-		return fmt.Errorf("cannot set out. Pass a reference to set output")
-	}
-
-	return nil
-}
 
 func validateMapperFunction(mapper reflect.Value) error {
 	if mapper.Kind() != reflect.Func {