Merge branch 'release/v1.4.1'

Author: EvilLord666

README.md

@@ -7,7 +7,7 @@ Slice printing is **50% faster with 8 items** slice and **250% with 20 items** s
 ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/wissance/stringFormatter?style=plastic) 
 ![GitHub issues](https://img.shields.io/github/issues/wissance/stringFormatter?style=plastic)
 ![GitHub Release Date](https://img.shields.io/github/release-date/wissance/stringFormatter) 
-![GitHub release (latest by date)](https://img.shields.io/github/downloads/wissance/stringFormatter/v1.3.0/total?style=plastic)
+![GitHub release (latest by date)](https://img.shields.io/github/downloads/wissance/stringFormatter/v1.4.1/total?style=plastic)
 
 ![String Formatter: a convenient string formatting tool](img/sf_cover.png)
 
@@ -126,6 +126,13 @@ separator := ","
 result := stringFormatter.SliceToString(&slice, &separator)
 ```
 
+`SliceSameTypeToString` - function that converts typed slice to line with separator
+```go
+separator := ":"
+numericSlice := []int{100, 200, 400, 800}
+result := stringFormatter.SliceSameTypeToString(&numericSlice, &separator)
+```
+
 #### 2.4 Benchmarks of the SliceToString function
 
 `sf` is rather fast then `fmt` 2.5 times (250%) faster on slice with 20 items, see benchmark:

formatter.go

@@ -339,9 +339,18 @@ func getItemAsStr(item *any, itemFormat *string) string {
 			if len(*itemFormat) > 1 {
 				separator = (*itemFormat)[1:]
 			}
+
 			// slice processing converting to {item}{delimiter}{item}{delimiter}{item}
-			slice := (*item).([]any)
-			return SliceToString(&slice, &separator)
+			slice, ok := (*item).([]any)
+			if ok {
+				if len(slice) == 1 {
+					// this is because slice in 0 item contains another slice, we should take it
+					slice, ok = slice[0].([]any)
+				}
+				return SliceToString(&slice, &separator)
+			} else {
+				return convertSliceToStrWithTypeDiscover(item, &separator)
+			}
 		default:
 			base = 10
 		}
@@ -419,3 +428,56 @@ func getItemAsStr(item *any, itemFormat *string) string {
 
 	return argStr
 }
+
+func convertSliceToStrWithTypeDiscover(slice *any, separator *string) string {
+	// 1. attempt to convert to int
+	iSlice, ok := (*slice).([]int)
+	if ok {
+		return SliceSameTypeToString(&iSlice, separator)
+	}
+
+	// 2. attempt to convert to string
+	sSlice, ok := (*slice).([]string)
+	if ok {
+		return SliceSameTypeToString(&sSlice, separator)
+	}
+
+	// 3. attempt to convert to float64
+	f64Slice, ok := (*slice).([]float64)
+	if ok {
+		return SliceSameTypeToString(&f64Slice, separator)
+	}
+
+	// 4. attempt to convert to float32
+	f32Slice, ok := (*slice).([]float32)
+	if ok {
+		return SliceSameTypeToString(&f32Slice, separator)
+	}
+
+	// 5. attempt to convert to bool
+	bSlice, ok := (*slice).([]bool)
+	if ok {
+		return SliceSameTypeToString(&bSlice, separator)
+	}
+
+	// 6. attempt to convert to int64
+	i64Slice, ok := (*slice).([]int64)
+	if ok {
+		return SliceSameTypeToString(&i64Slice, separator)
+	}
+
+	// 7. attempt to convert to uint
+	uiSlice, ok := (*slice).([]uint)
+	if ok {
+		return SliceSameTypeToString(&uiSlice, separator)
+	}
+
+	// 8. attempt to convert to int32
+	i32Slice, ok := (*slice).([]int32)
+	if ok {
+		return SliceSameTypeToString(&i32Slice, separator)
+	}
+
+	// default way ...
+	return fmt.Sprintf("%v", *slice)
+}

formatter_test.go

@@ -207,6 +207,61 @@ func TestFormatWithArgFormatting(t *testing.T) {
 	}
 }
 
+func TestFormatWithArgFormattingForTypedSlice(t *testing.T) {
+	for name, test := range map[string]struct {
+		template string
+		args     []any
+		expected string
+	}{
+		"list_with_int_slice": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]int{101, 202, 303}},
+			expected: "This is a list(slice) test: 101-202-303",
+		},
+		"list_with_uint_slice": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]uint{102, 204, 308}},
+			expected: "This is a list(slice) test: 102-204-308",
+		},
+		"list_with_int32_slice": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]int32{100, 200, 300}},
+			expected: "This is a list(slice) test: 100-200-300",
+		},
+		"list_with_int64_slice": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]int64{1001, 2002, 3003}},
+			expected: "This is a list(slice) test: 1001-2002-3003",
+		},
+		"list_with_float64_slice": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]float64{1.01, 2.02, 3.03}},
+			expected: "This is a list(slice) test: 1.01-2.02-3.03",
+		},
+		"list_with_float32_slice": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]float32{5.01, 6.02, 7.03}},
+			expected: "This is a list(slice) test: 5.01-6.02-7.03",
+		},
+		"list_with_bool_slice": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]bool{true, true, false}},
+			expected: "This is a list(slice) test: true-true-false",
+		},
+		"list_with_string_slice": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]string{"s1", "s2", "s3"}},
+			expected: "This is a list(slice) test: s1-s2-s3",
+		},
+	} {
+		// Run test here
+		t.Run(name, func(t *testing.T) {
+			// assert.NotNil(t, test)
+			assert.Equal(t, test.expected, stringFormatter.Format(test.template, test.args...))
+		})
+	}
+}
+
 // TestStrFormatWithComplicatedText - this test represents issue with complicated text
 func TestFormatComplex(t *testing.T) {
 	for name, test := range map[string]struct {

slicetostring.go

@@ -23,3 +23,23 @@ func SliceToString(data *[]any, separator *string) string {
 
 	return sliceStr.String()
 }
+
+func SliceSameTypeToString[T any](data *[]T, separator *string) string {
+	if len(*data) == 0 {
+		return ""
+	}
+
+	sliceStr := &strings.Builder{}
+	// init memory initially
+	sliceStr.Grow(len(*data)*len(*separator)*2 + (len(*data)-1)*len(*separator))
+	isFirst := true
+	for _, item := range *data {
+		if !isFirst {
+			sliceStr.WriteString(*separator)
+		}
+		sliceStr.WriteString(Format("{0}", item))
+		isFirst = false
+	}
+
+	return sliceStr.String()
+}

slicetostring_benchmark_test.go

@@ -29,6 +29,13 @@ func BenchmarkSliceToStringAdvanced10MixedItems(b *testing.B) {
 	}
 }
 
+func BenchmarkSliceToStringAdvanced10TypedItems(b *testing.B) {
+	slice := []int32{100, 102, 300, 404, 500, 600, 707, 800, 909, 1024}
+	for i := 0; i < b.N; i++ {
+		_ = stringFormatter.Format("{0:L,}", []any{slice})
+	}
+}
+
 func BenchmarkSliceStandard10MixedItems(b *testing.B) {
 	slice := []any{100, "200", 300, "400", 500, 600, "700", 800, 1.09, "hello"}
 	for i := 0; i < b.N; i++ {
@@ -39,9 +46,17 @@ func BenchmarkSliceStandard10MixedItems(b *testing.B) {
 func BenchmarkSliceToStringAdvanced20StrItems(b *testing.B) {
 	slice := []any{"str1", "str2", "str3", "str4", "str5", "str6", "str7", "str8", "str9", "str10",
 		"str11", "str12", "str13", "str14", "str15", "str16", "str17", "str18", "str19", "str20"}
+	for i := 0; i < b.N; i++ {
+		_ = stringFormatter.Format("{0:L,}", []any{slice})
+	}
+}
+
+func BenchmarkSliceToStringAdvanced20TypedStrItems(b *testing.B) {
+	slice := []string{"str1", "str2", "str3", "str4", "str5", "str6", "str7", "str8", "str9", "str10",
+		"str11", "str12", "str13", "str14", "str15", "str16", "str17", "str18", "str19", "str20"}
 	separator := ","
 	for i := 0; i < b.N; i++ {
-		_ = stringFormatter.SliceToString(&slice, &separator)
+		_ = stringFormatter.SliceSameTypeToString(&slice, &separator)
 	}
 }
 

slicetostring_test.go

@@ -29,3 +29,10 @@ func TestSliceToString(t *testing.T) {
 		})
 	}
 }
+
+func TestSliceSameTypeToString(t *testing.T) {
+	separator := ":"
+	numericSlice := []int{100, 200, 400, 800}
+	result := stringFormatter.SliceSameTypeToString(&numericSlice, &separator)
+	assert.Equal(t, "100:200:400:800", result)
+}