Support maps in Map

Signed-off-by: Prabhu Jayakumar <[email protected]>

Author: prabhu43

map.go

@@ -28,9 +28,6 @@ func Map(in, out, mapperFn interface{}) error {
 	}
 
 	mapperFnType := mapper.Type()
-	if mapperFnType.NumIn() != 1 {
-		return fmt.Errorf("mapper function has to take only one argument")
-	}
 
 	if mapperFnType.NumOut() != 1 {
 		return fmt.Errorf("mapper function should return only one return value")
@@ -40,6 +37,11 @@ func Map(in, out, mapperFn interface{}) error {
 		if output.Elem().Kind() != reflect.Slice {
 			return fmt.Errorf("output should be a slice for input of type slice")
 		}
+
+		if mapperFnType.NumIn() != 1 {
+			return fmt.Errorf("mapper function has to take only one argument")
+		}
+
 		if input.Type().Elem() != mapper.Type().In(0) {
 			return fmt.Errorf("mapper function's first argument (%s) has to be (%s)", mapper.Type().In(0), input.Type().Elem())
 		}
@@ -59,5 +61,37 @@ func Map(in, out, mapperFn interface{}) error {
 
 		return nil
 	}
+
+	if input.Kind() == reflect.Map {
+		if output.Elem().Kind() != reflect.Slice {
+			return fmt.Errorf("output should be a slice for input of type slice")
+		}
+
+		if mapperFnType.NumIn() != 2 {
+			return fmt.Errorf("mapper function has to take exactly two arguments")
+		}
+
+		if mapper.Type().In(0) != input.Type().Key() {
+			return fmt.Errorf("mapper function's first argument (%s) has to be (%s)", mapper.Type().In(0), input.Type().Key())
+		}
+		if mapper.Type().In(1) != input.Type().Elem() {
+			return fmt.Errorf("mapper function's second argument (%s) has to be (%s)", mapper.Type().In(1), input.Type().Elem())
+		}
+		if mapper.Type().Out(0) != output.Elem().Type().Elem() {
+			return fmt.Errorf("mapper function's return type has to be (%s) but is (%s)", mapper.Type().Out(0), output.Elem().Type().Elem())
+		}
+
+		result := reflect.MakeSlice(output.Elem().Type(), 0, input.Len())
+		for _, key :=  range input.MapKeys() {
+			value := input.MapIndex(key)
+
+			returnValues := mapper.Call([]reflect.Value{key, value})
+
+			result = reflect.Append(result, returnValues[0])
+		}
+		output.Elem().Set(result)
+
+		return nil
+	}
 	return fmt.Errorf("not implemented")
 }

map_test.go

@@ -141,6 +141,164 @@ func TestMap(t *testing.T) {
 	})
 }
 
+func TestMapForMap(t *testing.T) {
+	t.Run("support primitive type values", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+		out := make([]int, 0)
+
+		err := godash.Map(in, &out, func(key string, value int) int {
+			return value * value
+		})
+
+		expected := []int{1, 4, 9}
+		assert.NoError(t, err)
+		assert.ElementsMatch(t, expected, out)
+	})
+
+	t.Run("support structs", func(t *testing.T) {
+		type person struct {
+			name string
+		}
+
+		in := map[string]person{
+			"person1": {name: "john"},
+			"person2": {name: "doe"},
+		}
+		out := make([]string, 0)
+		expected := []string{"john", "doe"}
+
+		err := godash.Map(in, &out, func(key string, value person) string {
+			return value.name
+		})
+
+		assert.NoError(t, err)
+		assert.Equal(t, expected, out)
+	})
+
+	squared := func(key string, value int) int {
+		return value * value
+	}
+
+	t.Run("should not panic if output is nil", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+
+		{
+			var out []int
+
+			err := godash.Map(in, out, squared)
+
+			assert.EqualError(t, err, "output is nil. Pass a reference to set output")
+		}
+
+		{
+			err := godash.Map(in, nil, squared)
+
+			assert.EqualError(t, err, "output is nil. Pass a reference to set output")
+		}
+	})
+
+	t.Run("should not panic if output is not a slice", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+
+		var out int
+
+		err := godash.Map(in, &out, squared)
+
+		assert.EqualError(t, err, "output should be a slice for input of type slice")
+	})
+
+	t.Run("should not accept mapper function that are not functions", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+		var out []int
+
+		err := godash.Map(in, &out, 7)
+
+		assert.EqualError(t, err, "mapperFn has to be a function")
+	})
+
+	t.Run("should not accept mapper function that do not take exactly two arguments", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+		var out []int
+
+		{
+			err := godash.Map(in, &out, func() int { return 0 })
+			assert.EqualError(t, err, "mapper function has to take exactly two arguments")
+		}
+
+		{
+			err := godash.Map(in, &out, func(int) int { return 0 })
+			assert.EqualError(t, err, "mapper function has to take exactly two arguments")
+		}
+
+		{
+			err := godash.Map(in, &out, func(int, int, int) int { return 0 })
+			assert.EqualError(t, err, "mapper function has to take exactly two arguments")
+		}
+	})
+
+	t.Run("should not accept mapper function that do not return exactly one value", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+		var out []int
+
+		{
+			err := godash.Map(in, &out, func(int, int) {})
+			assert.EqualError(t, err, "mapper function should return only one return value")
+		}
+
+		{
+			err := godash.Map(in, &out, func(int, int) (int, int) { return 0, 0 })
+			assert.EqualError(t, err, "mapper function should return only one return value")
+		}
+	})
+
+	t.Run("should accept mapper function whose first argument's kind should be map's key kind", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+
+		var out []int
+
+		{
+			err := godash.Map(in, &out, func(int, int) string { return "" })
+			assert.EqualError(t, err, "mapper function's first argument (int) has to be (string)")
+		}
+
+		{
+			err := godash.Map(in, &out, func(string, int) int { return 0 })
+			assert.NoError(t, err)
+		}
+	})
+
+	t.Run("should accept mapper function whose second argument's kind should be map's value kind", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+
+		var out []int
+
+		{
+			err := godash.Map(in, &out, func(string, string) string { return "" })
+			assert.EqualError(t, err, "mapper function's second argument (string) has to be (int)")
+		}
+
+		{
+			err := godash.Map(in, &out, func(string, int) int { return 0 })
+			assert.NoError(t, err)
+		}
+	})
+
+	t.Run("should accept mapper function whose return's kind should be output slice's element kind", func(t *testing.T) {
+		in := map[string]int{"key1": 1, "key2": 2, "key3": 3}
+		var out []string
+
+		{
+			err := godash.Map(in, &out, func(string, int) int { return 0 })
+			assert.EqualError(t, err, "mapper function's return type has to be (int) but is (string)")
+		}
+
+		{
+			err := godash.Map(in, &out, func(string, int) string { return "" })
+			assert.NoError(t, err)
+		}
+	})
+}
+
 func ExampleMap() {
 	input := []int{0, 1, 2, 3, 4}
 	var output []string
@@ -153,3 +311,16 @@ func ExampleMap() {
 
 	// Output: [0 1 4 9 16]
 }
+
+func ExampleMapForMaps() {
+	input := map[string]int{"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
+	var output []string
+
+	_ = godash.Map(input, &output, func(key string, num int) string {
+		return fmt.Sprintf("%d", num*num)
+	})
+
+	fmt.Println(output)
+
+	// Output: [0 1 4 9 16]
+}