GenerateSlice() improvements

CHANGES.md

@@ -1,5 +1,15 @@
 # **ANGoLS** Changes
 
+## 0.10.0-beta2 - 15th February 2026
+
+* added `GenerateSlice[T]()`;
+* added `GenerateSliceOfInteger[T]()`;
+* changed semantics of `GenerateSliceOfInt()`, `GenerateSliceOfUint()`, `GenerateSliceOfString()`,
+* refactored `GenerateSliceOfInt()` in terms of `GenerateSliceOfInteger[T, U]()`;
+* refactored `GenerateSliceOfUint()` in terms of `GenerateSliceOfInteger[T, U]()`;
+* refactored `SkipOneElement` and `SkipRemainingElements`;
+
+
 ## 0.10.0-beta1 - 7th February 2026
 
 * simple refactoring of `ASCIIToLower()` and `ASCIIToUpper()`;

NEWS.md

@@ -1,14 +1,16 @@
 # ANGoLS - NEWS <!-- omit in toc -->
 
 
-| Date                | News Item                                                                       |
-| ------------------- | ------------------------------------------------------------------------------- |
-| 3rd January 2026    | Release of [**ANGoLS** 0.9.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.9.0)  |
+| Date                | News Item                                                                                                  |
+| ------------------- | ---------------------------------------------------------------------------------------------------------- |
+| 15th February 2026  | Release of [**ANGoLS** 0.10.0-beta2](https://github.com/synesissoftware/ANGoLS/releases/tag/0.10.0-beta2)  |
+| 7th February 2026   | Release of [**ANGoLS** 0.10.0-beta1](https://github.com/synesissoftware/ANGoLS/releases/tag/0.10.0-beta1)  |
+| 3rd January 2026    | Release of [**ANGoLS** 0.9.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.9.0)                |
 | 15th September 2025 | Release of [**ANGoLS** 0.8.0-alpha1](https://github.com/synesissoftware/ANGoLS/releases/tag/0.8.0-alpha1)  |
-| 27th August 2025    | Release of [**ANGoLS** 0.7.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.7.0)  |
-| 20th August 2025    | Release of [**ANGoLS** 0.6.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.6.0)  |
-| 30th March 2019     | Release of [**ANGoLS** 0.5.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.5.0)  |
-| 11th March 2019     | Release of [**ANGoLS** 0.4.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.4.0)  |
+| 27th August 2025    | Release of [**ANGoLS** 0.7.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.7.0)                |
+| 20th August 2025    | Release of [**ANGoLS** 0.6.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.6.0)                |
+| 30th March 2019     | Release of [**ANGoLS** 0.5.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.5.0)                |
+| 11th March 2019     | Release of [**ANGoLS** 0.4.0](https://github.com/synesissoftware/ANGoLS/releases/tag/0.4.0)                |
 | 1st March 2019      | initial commit  |
 
 

slices/generate_slice.go

@@ -4,115 +4,171 @@
 
 /*
  * Created: 1st March 2019
- * Updated: 7th February 2026
+ * Updated: 15th February 2026
  */
 
 package slices
 
-import (
-	"errors"
-)
+type skipOneElement struct {
+	s string
+}
 
-var SkipOneElement = errors.New("Skip one element")
-var SkipRemainingElements = errors.New("Skip remaining elements")
+func (e *skipOneElement) Error() string {
+	return e.s
+}
 
-// Creates a slice of a given size and populates its values with the given
-// generator (which may be nil).
-func GenerateSliceOfInt(size int, generator func(index int) (result int, err error)) (result []int, err error) {
+type skipRemainingElements struct {
+	s string
+}
 
-	result = make([]int, size)
+func (e *skipRemainingElements) Error() string {
+	return e.s
+}
 
-	if generator != nil {
+// Causes generation of a single element to be skipped.
+var SkipOneElement = &skipOneElement{s: "Skip one element"}
 
-		for i := 0; size != i; i++ {
+// Causes generation of all remaining elements to be skipped.
+var SkipRemainingElements = &skipRemainingElements{s: "Skip remaining elements"}
 
-			value, err := generator(i)
+func generateSliceOfBuiltIn[T bool | int8 | int16 | int32 | int64 | int | uint8 | uint16 | uint32 | uint64 | uint | uintptr | float32 | float64 | complex64 | complex128 | string](size int, generator func(index int) (result T, err error)) (result []T, err error) {
 
-			if err == nil {
+	result = make([]T, 0, size)
 
-				result[i] = value
-			} else {
+	var i int
+
+	for {
+		if size == 0 {
+			break;
+		} else {
+			if size > 0 {
+				size--
+			}
+		}
+
+		value, err := generator(i)
 
-				if SkipOneElement == err {
+		if err == nil {
 
-				} else if SkipRemainingElements == err {
+			result = append(result, value)
+		} else {
 
-					break
-				} else {
+			if SkipOneElement == err {
 
-					return nil, err
-				}
+			} else if SkipRemainingElements == err {
+
+				break
+			} else {
+
+				return nil, err
 			}
 		}
+
+		i++
 	}
 
 	return
 }
 
-// Creates a slice of a given size and populates its values with the given
-// generator (which may be nil).
-func GenerateSliceOfUint(size int, generator func(index int) (result uint, err error)) (result []uint, err error) {
+// Creates a slice of []T up to a maximum size and populates its values with
+// those created by the given generator.
+//
+// Parameters:
+//   - `size` - maximum size if non-negative; otherwise size unlimited;
+//   - `generator` - function that receives the given loop index, returning
+//     a result to be added into the result-slice, or one of the specific
+//     errors SkipOneElement (to skip a single element) or
+//     SkipRemainingElements (to skip all remaining elements), or another
+//     error to cause the operation to fail;
+func GenerateSlice[T any](size int, generator func(index int) (result T, err error)) (result []T, err error) {
+
+	result = make([]T, 0, size)
+
+	var i int
+
+	for {
+		if size == 0 {
+			break;
+		} else {
+			if size > 0 {
+				size--
+			}
+		}
 
-	result = make([]uint, size)
+		value, err := generator(i)
 
-	if generator != nil {
+		if err == nil {
 
-		for i := 0; size != i; i++ {
+			result = append(result, value)
+		} else {
 
-			value, err := generator(i)
+			if SkipOneElement == err {
 
-			if err == nil {
+			} else if SkipRemainingElements == err {
 
-				result[i] = value
+				break
 			} else {
 
-				if SkipOneElement == err {
-
-				} else if SkipRemainingElements == err {
-
-					break
-				} else {
-
-					return nil, err
-				}
+				return nil, err
 			}
 		}
+
+		i++
 	}
 
 	return
 }
 
-// Creates a slice of a given size and populates its values with the given
-// generator (which may be nil).
-func GenerateSliceOfString(size int, generator func(index int) (result string, err error)) (result []string, err error) {
-
-	result = make([]string, size)
-
-	if generator != nil {
-
-		for i := 0; size != i; i++ {
-
-			value, err := generator(i)
-
-			if err == nil {
+// Creates a slice of []N up to a maximum size and populates its values with
+// those created by the given generator.
+//
+// Parameters:
+//   - `size` - maximum size if non-negative; otherwise size unlimited;
+//   - `generator` - function that receives the given loop index, returning
+//     a result to be added into the result-slice, or one of the specific
+//     errors SkipOneElement (to skip a single element) or
+//     SkipRemainingElements (to skip all remaining elements), or another
+//     error to cause the operation to fail;
+func GenerateSliceOfInteger[N int8 | int16 | int32 | int64 | int | uint8 | uint16 | uint32 | uint64 | uint | uintptr](size int, generator func(index int) (result N, err error)) (result []N, err error) {
+
+	return generateSliceOfBuiltIn(size, generator)
+}
 
-				result[i] = value
-			} else {
+// Creates a slice of []int up to a maximum size and populates its values
+// with those created by the given generator.
+//
+// Parameters:
+//   - `size` - maximum size if non-negative; otherwise size unlimited;
+//   - `generator` - function that receives the given loop index, returning
+//     a result to be added into the result-slice, or one of the specific
+//     errors SkipOneElement (to skip a single element) or
+//     SkipRemainingElements (to skip all remaining elements), or another
+//     error to cause the operation to fail;
+func GenerateSliceOfInt(size int, generator func(index int) (result int, err error)) (result []int, err error) {
 
-				if SkipOneElement == err {
+	return GenerateSliceOfInteger(size, generator)
+}
 
-				} else if SkipRemainingElements == err {
+// Creates a slice of []uint up to a maximum size and populates its values
+// with those created by the given generator.
+//
+// Parameters:
+//   - `size` - maximum size if non-negative; otherwise size unlimited;
+//   - `generator` - function that receives the given loop index, returning
+//     a result to be added into the result-slice, or one of the specific
+//     errors SkipOneElement (to skip a single element) or
+//     SkipRemainingElements (to skip all remaining elements), or another
+//     error to cause the operation to fail;
+func GenerateSliceOfUint(size int, generator func(index int) (result uint, err error)) (result []uint, err error) {
 
-					break
-				} else {
+	return GenerateSliceOfInteger(size, generator)
+}
 
-					return nil, err
-				}
-			}
-		}
-	}
+// Creates a slice of a given size and populates its values with the given
+// generator (which may be nil).
+func GenerateSliceOfString(size int, generator func(index int) (result string, err error)) (result []string, err error) {
 
-	return
+	return generateSliceOfBuiltIn(size, generator)
 }
 
 /* ///////////////////////////// end of file //////////////////////////// */