Implement "Any" function

Author: arunvelsriram

README.md

@@ -17,6 +17,7 @@ This library heavily makes use of `reflect` package and hence will have an **imp
 1. [Map](#Map)
 2. [Filter](#Filter)
 3. [Reduce](#Reduce)
+4. [Any](#Any)
 
 ## Usages
 
@@ -141,3 +142,37 @@ func main() {
 	fmt.Println(output) // prints 45
 }
 ```
+
+### Any
+
+Any checks if predicate returns truthy for any element of collection. Iteration is stopped once predicate returns truthy.
+For more [docs](https://godoc.org/github.com/thecasualcoder/godash#Any).
+
+```go
+func main() {
+	input := []int{1, 2, 3, 4, 5}
+	var output []int
+
+	output, _ := godash.Any(input, func(num int) bool {
+		return num % 7 == 0
+	})
+
+	fmt.Println(output) // prints false
+}
+```
+
+```go
+func main() {
+	input := []Person{
+		{Name: "John", Age: 25},
+		{Name: "Doe", Age: 15},
+	}
+	var output int
+
+	output, _ := godash.Any(input, func(person Person) bool {
+		return person.Age < 18
+	})
+
+	fmt.Println(output) // prints true
+}
+```

any.go

@@ -0,0 +1,60 @@
+package godash
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Any checks if predicate returns truthy for any element of collection. Iteration is stopped once predicate returns truthy.
+// Currently, input of type slice is supported
+//
+// Validations:
+//
+// 1. Predicate function should take one argument and return one value
+// 2. Predicate function should return a bool value
+// 3. Predicate function's argument should be of the same type as the elements of the input slice
+//
+// Validation errors are returned to the caller
+func Any(in, predicateFn interface{}) (bool, error) {
+	var output bool
+	input := reflect.ValueOf(in)
+	predicate := reflect.ValueOf(predicateFn)
+
+	if predicate.Kind() != reflect.Func {
+		return output, fmt.Errorf("predicateFn has to be a function")
+	}
+
+	predicateFnType := predicate.Type()
+	if predicateFnType.NumIn() != 1 {
+		return output, fmt.Errorf("predicate function has to take only one argument")
+	}
+
+	if predicateFnType.NumOut() != 1 {
+		return output, fmt.Errorf("predicate function should return only one return value")
+	}
+
+	if predicateFnType.Out(0).Kind() != reflect.Bool {
+		return output, fmt.Errorf("predicate function should return a boolean value")
+	}
+
+	inputKind := input.Kind()
+	if inputKind == reflect.Slice {
+		inputSliceElemType := input.Type().Elem
+		predicateFnArgType := predicateFnType.In(0)
+		if inputSliceElemType() != predicateFnArgType {
+			return output, fmt.Errorf("predicate function's argument (%s) has to be (%s)", predicateFnArgType, inputSliceElemType())
+		}
+
+		for i := 0; i < input.Len(); i++ {
+			arg := input.Index(i)
+			returnValue := predicate.Call([]reflect.Value{arg})[0]
+			if returnValue.Bool() {
+				return true, nil
+			}
+		}
+
+		return output, nil
+	}
+
+	return output, fmt.Errorf("not implemented for (%s)", inputKind)
+}

any_test.go

@@ -0,0 +1,128 @@
+package godash_test
+
+import (
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/thecasualcoder/godash"
+	"testing"
+)
+
+func TestAny(t *testing.T) {
+
+	t.Run("should return err if predicate is not a function", func(t *testing.T) {
+		in := []int{1, 2, 3}
+
+		_, err := godash.Any(in, "not a func")
+
+		assert.EqualError(t, err, "predicateFn has to be a function")
+	})
+
+	t.Run("should return err if predicate function do not take exactly one argument", func(t *testing.T) {
+		in := []int{1, 2, 3}
+
+		{
+			_, err := godash.Any(in, func() {})
+
+			assert.EqualError(t, err, "predicate function has to take only one argument")
+		}
+		{
+			_, err := godash.Any(in, func(int, int) {})
+
+			assert.EqualError(t, err, "predicate function has to take only one argument")
+		}
+	})
+
+	t.Run("should return err if predicate function do not return exactly one value", func(t *testing.T) {
+		in := []int{1, 2, 3}
+
+		{
+			_, err := godash.Any(in, func(int) {})
+
+			assert.EqualError(t, err, "predicate function should return only one return value")
+		}
+		{
+			_, err := godash.Any(in, func(int) (bool, bool) { return true, true })
+
+			assert.EqualError(t, err, "predicate function should return only one return value")
+
+		}
+	})
+
+	t.Run("should return err if predicate function's return value is not a boolean", func(t *testing.T) {
+		in := []int{1, 2, 3}
+
+		_, err := godash.Any(in, func(int) int { return 0 })
+
+		assert.EqualError(t, err, "predicate function should return a boolean value")
+	})
+
+	t.Run("should return err if input is not a slice", func(t *testing.T) {
+		in := 1
+
+		_, err := godash.Any(in, func(int) bool { return true })
+
+		assert.EqualError(t, err, "not implemented for (int)")
+	})
+
+	t.Run("should return err if there is a type mismatch between predicate function's argument and input slice", func(t *testing.T) {
+		in := []string{"hello", "world"}
+
+		_, err := godash.Any(in, func(int) bool { return true })
+
+		assert.EqualError(t, err, "predicate function's argument (int) has to be (string)")
+	})
+
+	t.Run("should return true if predicate passes for any of the element in input slice", func(t *testing.T) {
+		in := []int{1, 1, 2, 3, 5, 8, 13}
+
+		output, err := godash.Any(in, func(elem int) bool { return elem%5 == 0 })
+
+		assert.NoError(t, err)
+		assert.True(t, output)
+	})
+
+	t.Run("should return false if predicate fails for all the elements in input slice", func(t *testing.T) {
+		in := []int{1, 1, 2, 3, 5, 8, 13}
+
+		output, err := godash.Any(in, func(num int) bool { return num%6 == 0 })
+
+		assert.NoError(t, err)
+		assert.False(t, output)
+	})
+
+	t.Run("should support structs", func(t *testing.T) {
+		type person struct {
+			name string
+			age  int
+		}
+		in := []person{
+			{name: "John", age: 12},
+			{name: "Doe", age: 25},
+		}
+
+		{
+			output, err := godash.Any(in, func(person person) bool { return person.age < 18 })
+
+			assert.NoError(t, err)
+			assert.True(t, output)
+		}
+		{
+			output, err := godash.Any(in, func(person person) bool { return person.age < 30 })
+
+			assert.NoError(t, err)
+			assert.True(t, output)
+		}
+	})
+}
+
+func ExampleAny() {
+	input := []int{0, 1, 2, 3, 4}
+
+	output, _ := godash.Any(input, func(num int) bool {
+		return num%3 == 0
+	})
+
+	fmt.Println(output)
+
+	// Output: true
+}