Merge pull request thoas#131 from yangtau/feat/to-set

feat: add ToSet()

Author: thoas

README.rst

@@ -242,6 +242,33 @@ Transforms a slice of structs to a map based on a ``pivot`` field.
 
     mapping := funk.ToMap(results, "ID") // map[int]*Foo{1: f, 2: b}
 
+funk.ToSet
+..........
+
+Transforms an array or a slice to a set (a map with zero-size values).
+
+.. code-block:: go
+
+    f := Foo{
+        ID:        1,
+        FirstName: "Gilles",
+        LastName:  "Fabio",
+        Age:       70,
+    }
+
+    b := Foo{
+        ID:        2,
+        FirstName: "Florent",
+        LastName:  "Messa",
+        Age:       80,
+    }
+
+    mapping := funk.ToSet([]Foo{f, b}) // map[Foo]stuct{}{f: struct{}{}, b: struct{}{}}
+
+    mapping := funk.ToSet([4]int{1, 1, 2, 2}) // map[int]struct{}{1: struct{}{}, 2: struct{}{}}
+
+
+
 funk.Filter
 ...........
 

transform.go

@@ -98,6 +98,33 @@ func ToMap(in interface{}, pivot string) interface{} {
 	return collection.Interface()
 }
 
+// ToSet transforms a collection of instances to a Set.
+// []T => map[T]struct{}
+func ToSet(in interface{}) interface{} {
+	// input value must be a collection
+	if !IsCollection(in) {
+		panic(fmt.Sprintf("%v must be a slice or an array", in))
+	}
+
+	var (
+		empty      = struct{}{}
+		emptyType  = reflect.TypeOf(empty)
+		emptyValue = reflect.ValueOf(empty)
+	)
+
+	value := reflect.ValueOf(in)
+	elemType := value.Type().Elem()
+
+	// key of the set will be the input type
+	collection := reflect.MakeMap(reflect.MapOf(elemType, emptyType))
+
+	for i := 0; i < value.Len(); i++ {
+		collection.SetMapIndex(value.Index(i), emptyValue)
+	}
+
+	return collection.Interface()
+}
+
 func mapSlice(arrValue reflect.Value, funcValue reflect.Value) reflect.Value {
 	funcType := funcValue.Type()
 

transform_test.go

@@ -120,6 +120,50 @@ func TestToMap(t *testing.T) {
 	}
 }
 
+func TestToSet(t *testing.T) {
+	is := assert.New(t)
+
+	type Foo struct {
+		ID   int
+		Name string
+	}
+
+	var (
+		f1 = Foo{ID: 1, Name: "hello"}
+		f2 = Foo{ID: 1, Name: "hello"}
+	)
+
+	// [2]Foo -> map[Foo]struct{}
+	array := [2]Foo{f1, f2}
+
+	resultOfArray := ToSet(array)
+	is.True(reflect.TypeOf(resultOfArray).Kind() == reflect.Map)
+
+	setFromArray, ok := resultOfArray.(map[Foo]struct{})
+	is.True(ok)
+	is.True(len(setFromArray) == 1)
+
+	for k, v := range setFromArray {
+		is.True(reflect.TypeOf(v).Size() == 0)
+		is.True(k == f1)
+	}
+
+	// []*Foo -> map[*Foo]struct{}
+	slice := []*Foo{&f1, &f2, &f1, &f2}
+
+	resultOfSlice := ToSet(slice)
+	is.True(reflect.TypeOf(resultOfSlice).Kind() == reflect.Map)
+
+	setFromSlice, ok := resultOfSlice.(map[*Foo]struct{})
+	is.True(ok)
+	is.True(len(setFromSlice) == 2)
+
+	for k, v := range setFromSlice {
+		is.True(reflect.TypeOf(v).Size() == 0)
+		is.True(k == &f1 || k == &f2)
+	}
+}
+
 func TestChunk(t *testing.T) {
 	is := assert.New(t)