Merge pull request thoas#113 from vellotis/feature-predicates-for-contains-indexof-lastindexof

Add possibility to use predicate for `Contains`, `IndexOf` & `LastIndexOf` functions

Author: thoas

README.rst

@@ -109,6 +109,9 @@ this can be replaced by ``funk.Contains``:
 
     // slice of Foo ptr
     funk.Contains([]*Foo{f}, f) // true
+    funk.Contains([]*Foo{f}, func (foo *Foo) bool {
+        return foo.ID == f.ID
+    }) // true
     funk.Contains([]*Foo{f}, nil) // false
 
     b := &Foo{
@@ -126,6 +129,9 @@ this can be replaced by ``funk.Contains``:
 
     // even map
     funk.Contains(map[int]string{1: "Florent"}, 1) // true
+    funk.Contains(map[int]string{1: "Florent"}, func(key int, name string) bool {
+        return key == 1 // or `name == "Florent"` for the value type
+    }) // true
 
 see also, typesafe implementations: ContainsInt_, ContainsInt64_, ContainsFloat32_, ContainsFloat64_, ContainsString_
 
@@ -175,6 +181,9 @@ if the value cannot be found.
 
     // slice of string
     funk.IndexOf([]string{"foo", "bar"}, "bar") // 1
+    funk.IndexOf([]string{"foo", "bar"}, func(value string) bool {
+        return value == "bar"
+    }) // 1
     funk.IndexOf([]string{"foo", "bar"}, "gilles") // -1
 
 see also, typesafe implementations: IndexOfInt_, IndexOfInt64_, IndexOfFloat32_, IndexOfFloat64_, IndexOfString_
@@ -195,6 +204,9 @@ if the value cannot be found.
 
     // slice of string
     funk.LastIndexOf([]string{"foo", "bar", "bar"}, "bar") // 2
+    funk.LastIndexOf([]string{"foo", "bar"}, func(value string) bool {
+        return value == "bar"
+    }) // 2
     funk.LastIndexOf([]string{"foo", "bar"}, "gilles") // -1
 
 see also, typesafe implementations: LastIndexOfInt_, LastIndexOfInt64_, LastIndexOfFloat32_, LastIndexOfFloat64_, LastIndexOfString_

chain_builder_test.go

@@ -491,6 +491,12 @@ func TestChainContains(t *testing.T) {
 			In:       []string{"foo", "bar"},
 			Contains: "bar",
 		},
+		{
+			In:       []string{"foo", "bar"},
+			Contains: func (value string) bool {
+				return value == "bar"
+			},
+		},
 		{
 			In:       results,
 			Contains: f,
@@ -519,6 +525,12 @@ func TestChainContains(t *testing.T) {
 			In:       map[int]*Foo{1: f, 3: c},
 			Contains: 2,
 		},
+		{
+			In:       map[int]*Foo{1: f, 3: c},
+			Contains: func (key int, foo *Foo) bool {
+				return key == 3 && foo.FirstName == "Harald"
+			},
+		},
 	}
 
 	for idx, tc := range testCases {
@@ -810,6 +822,12 @@ func TestChainIndexOf(t *testing.T) {
 			In:   []string{"foo", "bar"},
 			Item: "bar",
 		},
+		{
+			In:   []string{"foo", "bar"},
+			Item: func (value string) bool {
+				return value == "bar"
+			},
+		},
 		{
 			In:   results,
 			Item: f,
@@ -888,6 +906,12 @@ func TestChainLastIndexOf(t *testing.T) {
 			In:   []string{"foo", "bar", "bar"},
 			Item: "bar",
 		},
+		{
+			In:   []string{"foo", "bar", "bar"},
+			Item: func (value string) bool {
+				return value == "bar"
+			},
+		},
 		{
 			In:   []int{1, 2, 2, 3},
 			Item: 2,

helpers.go

@@ -75,7 +75,7 @@ func PtrOf(itf interface{}) interface{} {
 func IsFunction(in interface{}, num ...int) bool {
 	funcType := reflect.TypeOf(in)
 
-	result := funcType.Kind() == reflect.Func
+	result := funcType != nil && funcType.Kind() == reflect.Func
 
 	if len(num) >= 1 {
 		result = result && funcType.NumIn() == num[0]
@@ -88,6 +88,27 @@ func IsFunction(in interface{}, num ...int) bool {
 	return result
 }
 
+// IsPredicate returns if the argument is a predicate function.
+func IsPredicate(in interface{}, inTypes ...reflect.Type) bool {
+	if len(inTypes) == 0 {
+		inTypes = append(inTypes, nil)
+	}
+
+	funcType := reflect.TypeOf(in)
+
+	result := funcType != nil && funcType.Kind() == reflect.Func
+
+	result = result && funcType.NumOut() == 1 && funcType.Out(0).Kind() == reflect.Bool
+	result = result && funcType.NumIn() == len(inTypes)
+
+	for i := 0; result && i < len(inTypes); i++ {
+		inType := inTypes[i]
+		result = inType == nil || inType.ConvertibleTo(funcType.In(i))
+	}
+
+	return result
+}
+
 // IsEqual returns if the two objects are equal
 func IsEqual(expected interface{}, actual interface{}) bool {
 	if expected == nil || actual == nil {

helpers_test.go

@@ -269,3 +269,32 @@ func TestIsIteratee(t *testing.T) {
 
 	is.False(IsIteratee(nil))
 }
+
+func TestIsFunction(t *testing.T) {
+	is := assert.New(t)
+
+	is.False(IsFunction(nil))
+	is.False(IsFunction(""))
+	is.True(IsFunction(func() {}))
+	is.True(IsFunction(func(string, string, string) bool { return false }, 3))
+	is.False(IsFunction(func(string, string, string) bool { return false }, 3, 0))
+	is.True(IsFunction(func(string, string, string) (bool, error) { return false, nil }, 3, 2))
+}
+
+func TestIsPredicate(t *testing.T) {
+	is := assert.New(t)
+
+	is.False(IsPredicate(nil))
+	is.False(IsPredicate(""))
+	is.False(IsPredicate(func() {}))
+	is.False(IsPredicate(func() bool { return false}))
+	is.True(IsPredicate(func(int) bool { return false}))
+	is.True(IsPredicate(func(int) bool { return false}, nil))
+	is.False(IsPredicate(func(int) bool { return false}, reflect.TypeOf("")))
+	is.True(IsPredicate(func(int) bool { return false}, reflect.TypeOf(0)))
+	is.False(IsPredicate(func(int, string) bool { return false}, reflect.TypeOf("")))
+	is.False(IsPredicate(func(int, string) bool { return false}, reflect.TypeOf(""), reflect.TypeOf(0)))
+	is.True(IsPredicate(func(int, string) bool { return false}, reflect.TypeOf(0), reflect.TypeOf("")))
+	is.False(IsPredicate(func(struct{}, string) bool { return false}, reflect.TypeOf(0), reflect.TypeOf("")))
+	is.True(IsPredicate(func(struct{}, string) bool { return false}, nil, reflect.TypeOf("")))
+}

lazy_builder_test.go

@@ -491,6 +491,12 @@ func TestLazyContains(t *testing.T) {
 			In:       []string{"foo", "bar"},
 			Contains: "bar",
 		},
+		{
+			In:       []string{"foo", "bar"},
+			Contains: func (value string) bool {
+				return value == "bar"
+			},
+		},
 		{
 			In:       results,
 			Contains: f,
@@ -519,6 +525,12 @@ func TestLazyContains(t *testing.T) {
 			In:       map[int]*Foo{1: f, 3: c},
 			Contains: 2,
 		},
+		{
+			In:       map[int]*Foo{1: f, 3: c},
+			Contains: func (key int, foo *Foo) bool {
+				return key == 3 && foo.FirstName == "Harald"
+			},
+		},
 	}
 
 	for idx, tc := range testCases {
@@ -810,6 +822,12 @@ func TestLazyIndexOf(t *testing.T) {
 			In:   []string{"foo", "bar"},
 			Item: "bar",
 		},
+		{
+			In:   []string{"foo", "bar"},
+			Item: func (value string) bool {
+				return value == "bar"
+			},
+		},
 		{
 			In:   results,
 			Item: f,
@@ -888,6 +906,12 @@ func TestLazyLastIndexOf(t *testing.T) {
 			In:   []string{"foo", "bar", "bar"},
 			Item: "bar",
 		},
+		{
+			In:   []string{"foo", "bar", "bar"},
+			Item: func (value string) bool {
+				return value == "bar"
+			},
+		},
 		{
 			In:   []int{1, 2, 2, 3},
 			Item: 2,

predicate.go

@@ -20,7 +20,7 @@ func predicatesImpl(value interface{}, wantedAnswer bool, predicates interface{}
 		}
 
 		funcType := funcValue.Type()
-		if funcType.NumIn() != 1 || funcType.NumOut() != 1 || funcType.Out(0).Kind() != reflect.Bool {
+		if !IsPredicate(funcValue.Interface()) {
 			panic("Predicate function must have 1 parameter and must return boolean")
 		}
 

presence.go

@@ -118,8 +118,9 @@ func IndexOf(in interface{}, elem interface{}) int {
 	}
 
 	if inType.Kind() == reflect.Slice {
+		equalTo := equal(elem)
 		for i := 0; i < inValue.Len(); i++ {
-			if equal(inValue.Index(i).Interface(), elem) {
+			if equalTo(reflect.Value{}, inValue.Index(i)) {
 				return i
 			}
 		}
@@ -144,8 +145,9 @@ func LastIndexOf(in interface{}, elem interface{}) int {
 	if inType.Kind() == reflect.Slice {
 		length := inValue.Len()
 
+		equalTo := equal(elem)
 		for i := length - 1; i >= 0; i-- {
-			if equal(inValue.Index(i).Interface(), elem) {
+			if equalTo(reflect.Value{}, inValue.Index(i)) {
 				return i
 			}
 		}
@@ -164,14 +166,16 @@ func Contains(in interface{}, elem interface{}) bool {
 	case reflect.String:
 		return strings.Contains(inValue.String(), elemValue.String())
 	case reflect.Map:
+		equalTo := equal(elem, true)
 		for _, key := range inValue.MapKeys() {
-			if equal(key.Interface(), elem) {
+			if equalTo(key, inValue.MapIndex(key)) {
 				return true
 			}
 		}
 	case reflect.Slice, reflect.Array:
+		equalTo := equal(elem)
 		for i := 0; i < inValue.Len(); i++ {
-			if equal(inValue.Index(i).Interface(), elem) {
+			if equalTo(reflect.Value{}, inValue.Index(i)) {
 				return true
 			}
 		}

presence_test.go

@@ -54,6 +54,20 @@ func TestContains(t *testing.T) {
 
 	is.True(Contains(mapping, 1))
 	is.False(Contains(mapping, 2))
+
+	is.False(Contains(mapping, func (key int, val *Foo) bool {
+		return key == 4
+	}))
+	is.True(Contains(mapping, func (key int, val *Foo) bool {
+		return key == 1
+	}))
+
+	is.False(Contains(mapping, func (_ int, val *Foo) bool {
+		return val.FirstName == "NotPresent"
+	}))
+	is.True(Contains(mapping, func (_ int, val *Foo) bool {
+		return val.FirstName == "Harald"
+	}))
 }
 
 func TestEvery(t *testing.T) {
@@ -117,6 +131,9 @@ func TestIndexOf(t *testing.T) {
 	is := assert.New(t)
 
 	is.Equal(IndexOf([]string{"foo", "bar"}, "bar"), 1)
+	is.Equal(IndexOf([]string{"foo", "bar"}, func (value string) bool {
+		return value == "bar"
+	}), 1)
 
 	is.Equal(IndexOf(results, f), 0)
 	is.Equal(IndexOf(results, b), -1)
@@ -126,6 +143,9 @@ func TestLastIndexOf(t *testing.T) {
 	is := assert.New(t)
 
 	is.Equal(LastIndexOf([]string{"foo", "bar", "bar"}, "bar"), 2)
+	is.Equal(LastIndexOf([]string{"foo", "bar", "bar"}, func (value string) bool {
+		return value == "bar"
+	}), 2)
 	is.Equal(LastIndexOf([]int{1, 2, 2, 3}, 2), 2)
 	is.Equal(LastIndexOf([]int{1, 2, 2, 3}, 4), -1)
 }

utils.go

@@ -1,16 +1,57 @@
 package funk
 
 import (
+	"fmt"
 	"reflect"
 )
 
-func equal(expected, actual interface{}) bool {
-	if expected == nil || actual == nil {
-		return expected == actual
+func equal(expectedOrPredicate interface{}, optionalIsMap ...bool) func(keyValueIfMap, actualValue reflect.Value) bool {
+	isMap := append(optionalIsMap, false)[0]
+
+	if IsFunction(expectedOrPredicate) {
+		inTypes := []reflect.Type{nil}; if isMap {
+			inTypes = append(inTypes, nil)
+		}
+
+		if !IsPredicate(expectedOrPredicate, inTypes...) {
+			panic(fmt.Sprintf("Predicate function must have %d parameter and must return boolean", len(inTypes)))
+		}
+
+		predicateValue := reflect.ValueOf(expectedOrPredicate)
+
+		return func(keyValueIfMap, actualValue reflect.Value) bool {
+
+			if isMap && !keyValueIfMap.Type().ConvertibleTo(predicateValue.Type().In(0)) {
+				panic("Given key is not compatible with type of parameter for the predicate.")
+			}
+
+			if (isMap && !actualValue.Type().ConvertibleTo(predicateValue.Type().In(1))) ||
+				(!isMap && !actualValue.Type().ConvertibleTo(predicateValue.Type().In(0))) {
+				panic("Given value is not compatible with type of parameter for the predicate.")
+			}
+
+			args := []reflect.Value{actualValue}
+			if isMap {
+				args = append([]reflect.Value{keyValueIfMap}, args...)
+			}
+
+			return predicateValue.Call(args)[0].Bool()
+		}
 	}
 
-	return reflect.DeepEqual(expected, actual)
+	expected := expectedOrPredicate
+
+	return func(keyValueIfMap, actualValue reflect.Value) bool {
+		if isMap {
+			actualValue = keyValueIfMap
+		}
+
+		if expected == nil || actualValue.IsZero() {
+			return actualValue.Interface() == expected
+		}
 
+		return reflect.DeepEqual(actualValue.Interface(), expected)
+	}
 }
 
 func sliceElem(rtype reflect.Type) reflect.Type {