Added function - sort in method chain functionality

Author: Sah, Nandeshwar

README.md

@@ -21,7 +21,7 @@ go install github.com/logic-building/functional-go/gofp
 ```toml
 [[constraint]]
 name = "github.com/logic-building/functional-go"
-version = "8.13.1"
+version = "8.14.0"
 ```
 
 ### Quick Start
@@ -36,7 +36,7 @@ func square(num int) int {
 }
 
 ```
-#### Four variants of function. 1 is given above and 3 are given below
+#### Four variants of the function. 1 is given above and 3 are given below
 ##### MapInt, MapIntPtr, MapIntErr, MapIntPtrErr
 ### MapIntPtr
 ```go
@@ -341,6 +341,27 @@ Note:
 26. Union     : Return a set that is the union of the input sets. Repeated value within list(argument) will be ignored
 27. Union<struct>By<Field>
 ```
+
+### Method chain functionality for Basic type as well as struct - 
+#### Map, Filter, Sort, Distinct, Reverse, DropWhile, Remove
+#### Examples
+```go
+// Use MakeIntSlicePtr for pointer version
+r := fp.MakeIntSlice([]int{3, 2, 1}...).
+        Filter(odd).
+        Map(square).
+        Sort()
+fmt.Println(r) // [1 9]
+
+func odd (num int) bool {
+        return num % 2 != 0
+}
+func square(num int) int {
+        return num * num
+}
+    
+```
+
 ### Contains functions
 ```
 Takes list as argument and returns Distinct list.  Returns empty list if 2nd parameter is empty or nil

fp/distinct.go

@@ -254,3 +254,17 @@ func DistinctStrIgnoreCase(list []string) []string {
 	}
 	return newList
 }
+
+// DistinctBool removes duplicates.
+func DistinctBool(list []bool) []bool {
+	var newList []bool
+	s := make(map[bool]struct{}, len(list))
+	for _, v := range list {
+		if _, ok := s[v]; ok {
+			continue
+		}
+		s[v] = struct{}{}
+		newList = append(newList, v)
+	}
+	return newList
+}

fp/distinct_test.go

@@ -407,3 +407,16 @@ func TestDistinctStrIgnoreCase(t *testing.T) {
 		t.Errorf("DistinctStr failed. Expected=%v, actual=%v", expected, distinct)
 	}
 }
+
+func TestDistinctBool(t *testing.T) {
+	var vt bool = true
+
+	newList := DistinctBool([]bool{vt, vt})
+	if newList[0] != vt {
+		t.Errorf("DistinctBool failed")
+	}
+
+	if len(DistinctBool(nil)) > 0 {
+		t.Errorf("DistinctBool failed.")
+	}
+}

fp/methodchain.go

@@ -150,6 +150,16 @@ func (slice intSlicePtr) ReversePtr() intSlicePtr {
 	return ReverseIntsPtr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice intSlice) Distinct() intSlice {
+	return DistinctInt(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice intSlicePtr) DistinctPtr() intSlicePtr {
+	return DistinctIntPtr(slice)
+}
+
 type int64Slice []int64
 type int64FunctorForMap func(int64) int64
 type int64FunctorForFilter func(int64) bool
@@ -300,6 +310,16 @@ func (slice int64SlicePtr) ReversePtr() int64SlicePtr {
 	return ReverseInts64Ptr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice int64Slice) Distinct() int64Slice {
+	return DistinctInt64(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice int64SlicePtr) DistinctPtr() int64SlicePtr {
+	return DistinctInt64Ptr(slice)
+}
+
 type int32Slice []int32
 type int32FunctorForMap func(int32) int32
 type int32FunctorForFilter func(int32) bool
@@ -450,6 +470,16 @@ func (slice int32SlicePtr) ReversePtr() int32SlicePtr {
 	return ReverseInts32Ptr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice int32Slice) Distinct() int32Slice {
+	return DistinctInt32(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice int32SlicePtr) DistinctPtr() int32SlicePtr {
+	return DistinctInt32Ptr(slice)
+}
+
 type int16Slice []int16
 type int16FunctorForMap func(int16) int16
 type int16FunctorForFilter func(int16) bool
@@ -600,6 +630,16 @@ func (slice int16SlicePtr) ReversePtr() int16SlicePtr {
 	return ReverseInts16Ptr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice int16Slice) Distinct() int16Slice {
+	return DistinctInt16(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice int16SlicePtr) DistinctPtr() int16SlicePtr {
+	return DistinctInt16Ptr(slice)
+}
+
 type int8Slice []int8
 type int8FunctorForMap func(int8) int8
 type int8FunctorForFilter func(int8) bool
@@ -750,6 +790,16 @@ func (slice int8SlicePtr) ReversePtr() int8SlicePtr {
 	return ReverseInts8Ptr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice int8Slice) Distinct() int8Slice {
+	return DistinctInt8(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice int8SlicePtr) DistinctPtr() int8SlicePtr {
+	return DistinctInt8Ptr(slice)
+}
+
 type uintSlice []uint
 type uintFunctorForMap func(uint) uint
 type uintFunctorForFilter func(uint) bool
@@ -900,6 +950,16 @@ func (slice uintSlicePtr) ReversePtr() uintSlicePtr {
 	return ReverseUintsPtr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice uintSlice) Distinct() uintSlice {
+	return DistinctUint(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice uintSlicePtr) DistinctPtr() uintSlicePtr {
+	return DistinctUintPtr(slice)
+}
+
 type uint64Slice []uint64
 type uint64FunctorForMap func(uint64) uint64
 type uint64FunctorForFilter func(uint64) bool
@@ -1050,6 +1110,16 @@ func (slice uint64SlicePtr) ReversePtr() uint64SlicePtr {
 	return ReverseUint64sPtr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice uint64Slice) Distinct() uint64Slice {
+	return DistinctUint64(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice uint64SlicePtr) DistinctPtr() uint64SlicePtr {
+	return DistinctUint64Ptr(slice)
+}
+
 type uint32Slice []uint32
 type uint32FunctorForMap func(uint32) uint32
 type uint32FunctorForFilter func(uint32) bool
@@ -1200,6 +1270,16 @@ func (slice uint32SlicePtr) ReversePtr() uint32SlicePtr {
 	return ReverseUints32Ptr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice uint32Slice) Distinct() uint32Slice {
+	return DistinctUint32(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice uint32SlicePtr) DistinctPtr() uint32SlicePtr {
+	return DistinctUint32Ptr(slice)
+}
+
 type uint16Slice []uint16
 type uint16FunctorForMap func(uint16) uint16
 type uint16FunctorForFilter func(uint16) bool
@@ -1350,6 +1430,16 @@ func (slice uint16SlicePtr) ReversePtr() uint16SlicePtr {
 	return ReverseUints16Ptr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice uint16Slice) Distinct() uint16Slice {
+	return DistinctUint16(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice uint16SlicePtr) DistinctPtr() uint16SlicePtr {
+	return DistinctUint16Ptr(slice)
+}
+
 type uint8Slice []uint8
 type uint8FunctorForMap func(uint8) uint8
 type uint8FunctorForFilter func(uint8) bool
@@ -1500,6 +1590,16 @@ func (slice uint8SlicePtr) ReversePtr() uint8SlicePtr {
 	return ReverseUints8Ptr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice uint8Slice) Distinct() uint8Slice {
+	return DistinctUint8(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice uint8SlicePtr) DistinctPtr() uint8SlicePtr {
+	return DistinctUint8Ptr(slice)
+}
+
 type stringSlice []string
 type stringFunctorForMap func(string) string
 type stringFunctorForFilter func(string) bool
@@ -1650,6 +1750,16 @@ func (slice stringSlicePtr) ReversePtr() stringSlicePtr {
 	return ReverseStrsPtr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice stringSlice) Distinct() stringSlice {
+	return DistinctStr(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice stringSlicePtr) DistinctPtr() stringSlicePtr {
+	return DistinctStrPtr(slice)
+}
+
 type boolSlice []bool
 type boolFunctorForMap func(bool) bool
 type boolFunctorForFilter func(bool) bool
@@ -1800,6 +1910,16 @@ func (slice boolSlicePtr) ReversePtr() boolSlicePtr {
 	return ReverseBoolsPtr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice boolSlice) Distinct() boolSlice {
+	return DistinctBool(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice boolSlicePtr) DistinctPtr() boolSlicePtr {
+	return DistinctBoolPtr(slice)
+}
+
 type float32Slice []float32
 type float32FunctorForMap func(float32) float32
 type float32FunctorForFilter func(float32) bool
@@ -1950,6 +2070,16 @@ func (slice float32SlicePtr) ReversePtr() float32SlicePtr {
 	return ReverseFloat32sPtr(slice)
 }
 
+// Distinct - removes duplicates
+func (slice float32Slice) Distinct() float32Slice {
+	return DistinctFloat32(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice float32SlicePtr) DistinctPtr() float32SlicePtr {
+	return DistinctFloat32Ptr(slice)
+}
+
 type float64Slice []float64
 type float64FunctorForMap func(float64) float64
 type float64FunctorForFilter func(float64) bool
@@ -2099,3 +2229,13 @@ func (slice float64Slice) Reverse() float64Slice {
 func (slice float64SlicePtr) ReversePtr() float64SlicePtr {
 	return ReverseFloat64sPtr(slice)
 }
+
+// Distinct - removes duplicates
+func (slice float64Slice) Distinct() float64Slice {
+	return DistinctFloat64(slice)
+}
+
+// DistinctPtr - removes duplicates
+func (slice float64SlicePtr) DistinctPtr() float64SlicePtr {
+	return DistinctFloat64Ptr(slice)
+}