Implement "Some" function

Author: arunvelsriram

README.md

@@ -17,7 +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)
+4. [Any](#Any-or-Some) or [Some](#Any-or-Some)
 
 ## Usages
 
@@ -143,9 +143,9 @@ func main() {
 }
 ```
 
-### Any
+### Any or Some
 
-Any checks if predicate returns truthy for any element of collection. Iteration is stopped once predicate returns truthy.
+Any or Some 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
@@ -169,7 +169,7 @@ func main() {
 	}
 	var output int
 
-	output, _ := godash.Any(input, func(person Person) bool {
+	output, _ := godash.Some(input, func(person Person) bool {
 		return person.Age < 18
 	})
 

any.go

@@ -58,3 +58,8 @@ func Any(in, predicateFn interface{}) (bool, error) {
 
 	return output, fmt.Errorf("not implemented for (%s)", inputKind)
 }
+
+// Some is an alias for Any function
+func Some(in, predicateFn interface{}) (bool, error) {
+	return Any(in, predicateFn)
+}

any_test.go

@@ -7,118 +7,136 @@ import (
 	"testing"
 )
 
-func TestAny(t *testing.T) {
+func TestSomeAndAny(t *testing.T) {
+	var funcs = map[string]func(interface{}, interface{}) (bool, error){
+		"Any()":  godash.Any,
+		"Some()": godash.Some,
+	}
 
-	t.Run("should return err if predicate is not a function", func(t *testing.T) {
-		in := []int{1, 2, 3}
+	for fnName, fn := range funcs {
+		t.Run(fmt.Sprintf("%s should return err if predicate is not a function", fnName), func(t *testing.T) {
+			in := []int{1, 2, 3}
 
-		_, err := godash.Any(in, "not a func")
+			_, err := fn(in, "not a func")
 
-		assert.EqualError(t, err, "predicateFn has to be a function")
-	})
+			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}
+		t.Run(fmt.Sprintf("%s should return err if predicate function do not take exactly one argument", fnName), func(t *testing.T) {
+			in := []int{1, 2, 3}
 
-		{
-			_, err := godash.Any(in, func() {})
+			{
+				_, err := fn(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")
+			}
+			{
+				_, err := fn(in, func(int, int) {})
 
-			assert.EqualError(t, err, "predicate function has to take only one argument")
-		}
-	})
+				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}
+		t.Run(fmt.Sprintf("%s should return err if predicate function do not return exactly one value", fnName), func(t *testing.T) {
+			in := []int{1, 2, 3}
 
-		{
-			_, err := godash.Any(in, func(int) {})
+			{
+				_, err := fn(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")
+			}
+			{
+				_, err := fn(in, func(int) (bool, bool) { return true, true })
 
-			assert.EqualError(t, err, "predicate function should return only one return value")
+				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}
+		t.Run(fmt.Sprintf("%s should return err if predicate function's return value is not a boolean", fnName), func(t *testing.T) {
+			in := []int{1, 2, 3}
 
-		_, err := godash.Any(in, func(int) int { return 0 })
+			_, err := fn(in, func(int) int { return 0 })
 
-		assert.EqualError(t, err, "predicate function should return a boolean value")
-	})
+			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
+		t.Run(fmt.Sprintf("%s should return err if input is not a slice", fnName), func(t *testing.T) {
+			in := 1
 
-		_, err := godash.Any(in, func(int) bool { return true })
+			_, err := fn(in, func(int) bool { return true })
 
-		assert.EqualError(t, err, "not implemented for (int)")
-	})
+			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"}
+		t.Run(fmt.Sprintf("%s should return err if there is a type mismatch between predicate function's argument and input slice", fnName), func(t *testing.T) {
+			in := []string{"hello", "world"}
 
-		_, err := godash.Any(in, func(int) bool { return true })
+			_, err := fn(in, func(int) bool { return true })
 
-		assert.EqualError(t, err, "predicate function's argument (int) has to be (string)")
-	})
+			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}
+		t.Run(fmt.Sprintf("%s should return true if predicate passes for at least one of the element in input slice", fnName), 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 })
+			output, err := fn(in, func(elem int) bool { return elem%5 == 0 })
 
-		assert.NoError(t, err)
-		assert.True(t, output)
-	})
+			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}
+		t.Run(fmt.Sprintf("%s should return false if predicate fails for all the elements in input slice", fnName), 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 })
+			output, err := fn(in, func(num int) bool { return num%6 == 0 })
 
-		assert.NoError(t, err)
-		assert.False(t, output)
-	})
+			assert.NoError(t, err)
+			assert.False(t, output)
+		})
+
+		t.Run(fmt.Sprintf("%s should support structs", fnName), func(t *testing.T) {
+			type person struct {
+				name string
+				age  int
+			}
+			in := []person{
+				{name: "John", age: 12},
+				{name: "Doe", age: 25},
+			}
+
+			{
+				output, err := fn(in, func(person person) bool { return person.age < 18 })
+
+				assert.NoError(t, err)
+				assert.True(t, output)
+			}
+			{
+				output, err := fn(in, func(person person) bool { return person.age < 30 })
+
+				assert.NoError(t, err)
+				assert.True(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},
-		}
+func ExampleAny() {
+	input := []int{0, 1, 2, 3, 4}
 
-		{
-			output, err := godash.Any(in, func(person person) bool { return person.age < 18 })
+	output, _ := godash.Any(input, func(num int) bool {
+		return num%3 == 0
+	})
 
-			assert.NoError(t, err)
-			assert.True(t, output)
-		}
-		{
-			output, err := godash.Any(in, func(person person) bool { return person.age < 30 })
+	fmt.Println(output)
 
-			assert.NoError(t, err)
-			assert.True(t, output)
-		}
-	})
+	// Output: true
 }
 
-func ExampleAny() {
+func ExampleSome() {
 	input := []int{0, 1, 2, 3, 4}
 
-	output, _ := godash.Any(input, func(num int) bool {
+	output, _ := godash.Some(input, func(num int) bool {
 		return num%3 == 0
 	})