tinystring

README

TinyString

TinyString is a lightweight Go library that provides comprehensive string manipulation, type conversion, formatting, and multilingual error handling with a fluid API, specifically designed for small devices and web applications using TinyGo as the target compiler.

Key Features

• 🚀 Fluid and chainable API - Easy to use and readable operations
• 📝 Complete string toolkit - Transformations, conversions, formatting, and error handling
• 🌍 Multilingual error messages - Built-in dictionary system with 9 languages
• 🧵 Concurrency safe - Thread-safe operations for concurrent environments
• 📦 Zero dependencies - No fmt, strings, strconv, or errors imports
• 🎯 TinyGo optimized - Manual implementations for minimal binary size
• 🌐 WebAssembly-first - Designed for modern web deployment
• 🔄 Universal type support - Works with strings, numbers, booleans, and slices
• ⚡ Performance focused - Predictable allocations and custom optimizations

Why TinyString?

Go's WebAssembly potential is incredible, but traditional applications face a critical challenge: massive binary sizes that make web deployment impractical.

The Problem

Every Go project needs string manipulation, type conversion, and error handling - but importing standard library packages (fmt, strings, strconv, errors) creates significant binary bloat that hurts:

• 🌐 Web app performance - Slow loading times and poor user experience
• � Edge deployment - Resource constraints on small devices
• 🚀 Distribution efficiency - Large binaries for simple operations

The Solution

TinyString replaces multiple standard library packages with lightweight, manual implementations that deliver:

• 🏆 Up to smaller binaries - Dramatic size reduction for WebAssembly
• ✅ Full TinyGo compatibility - No compilation issues or warnings
• 🎯 Predictable performance - No hidden allocations or overhead
• 🔧 Familiar API - Drop-in replacement for standard library functions

Installation

go get github.com/cdvelop/tinystring

Usage

import "github.com/cdvelop/tinystring"

// Quick start - Basic conversion and transformation
text := tinystring.Convert("Hóla Múndo").RemoveTilde().ToLower().String()
// out: "hola mundo"

// Working with different data types
numText := tinystring.Convert(42).String()     // out: "42"
boolText := tinystring.Convert(true).String()  // out: "true"

// Memory-efficient approach using string pointers
original := "Él Múrcielago Rápido"
tinystring.Convert(&original).RemoveTilde().CamelCaseLower().Apply()
// original is now: "elMurcielagoRapido"

// Multilingual error messages (NEW!)
import . "github.com/cdvelop/tinystring"

OutLang(ES) // Set Spanish
err := Err(D.Invalid, D.Format)
// out: "inválido formato"

OutLang()   // Auto-detect system language
err = Err(D.Cannot, D.Round, D.NonNumeric, D.Value).Error()
// Output in user's detected language

🔧 Builder API

TinyString features a high-performance builder API for memory-efficient string operations. All operations work on a single internal buffer with object pooling.

Efficient Loop Processing

import "github.com/cdvelop/tinystring"

// Memory-efficient processing in loops
items := []string{"  APPLE  ", "  banana  ", "  Cherry  "}

c := tinystring.Convert() // Empty initialization
for i, item := range items {
    c.Write(item).Trim().ToLower().Capitalize()
    if i < len(items)-1 {
        c.Write(" - ")
    }
}
result := c.String() // "Apple - Banana - Cherry"

Key Builder Operations

// Reuse builder for multiple operations
builder := tinystring.Convert()

// Operation 1: Reset and build
builder.Reset()
result1 := builder.Write("Hello").Write(" World").String()

// Operation 2: Reset and transform
builder.Reset()
original := "test string"
tinystring.Convert(&original).ToUpper().RemoveTilde().Apply()
// original is now: "TEST STRING" - modified in-place

📚 Standard Library Equivalents

🔤 strings Package

Replace common strings package functions with TinyString equivalents:

Go Standard	TinyString Equivalent
strings.ToLower()	Convert(s).ToLower().String()
strings.ToUpper()	Convert(s).ToUpper().String()
strings.Contains()	Contains(s, substr)
strings.Replace()	Convert(s).Replace(old, new).String()
strings.Split()	Split(s, sep)
strings.Join()	Convert(slice).Join(sep).String()
strings.TrimSpace()	Convert(s).Trim().String()
strings.TrimPrefix()	Convert(s).TrimPrefix(prefix).String()
strings.TrimSuffix()	Convert(s).TrimSuffix(suffix).String()
strings.Repeat()	Convert(s).Repeat(n).String()
strings.Builder	Convert().Write(a).Write(b).String()

Builder API Advantages

The Builder API is especially efficient for complex operations:

// ❌ Standard approach - multiple allocations
result := tinystring.Convert("Hello").ToUpper().String() + " " + 
          tinystring.Convert("World").ToLower().String() + "!"
// Multiple Convert() calls = multiple allocations

// ✅ Builder approach - single allocation
result := tinystring.Convert().
    Write("Hello").ToUpper().
    Write(" ").
    Write("World").ToLower().
    Write("!").
    String()
// Single Convert() + reused buffer = optimal performance

String Transformations

// Case conversions
tinystring.Convert("HELLO").ToLower().String()              // out: "hello"
tinystring.Convert("world").ToUpper().String()              // out: "WORLD"
tinystring.Convert("hello world").Capitalize().String()     // out: "Hello World"

// Advanced case styles
tinystring.Convert("hello world").CamelCaseLower().String()   // out: "helloWorld"
tinystring.Convert("hello world").CamelCaseUpper().String()   // out: "HelloWorld"
tinystring.Convert("hello world").ToSnakeCaseLower().String() // out: "hello_world"
tinystring.Convert("hello world").ToSnakeCaseUpper().String() // out: "HELLO_WORLD"

String Search & Operations

// Search and count
found := tinystring.Contains("hello world", "world")              // out: true
count := tinystring.Count("abracadabra", "abra")       // out: 2

// Replace operations
tinystring.Convert("hello world").Replace("world", "Go").String() // out: "hello Go"
tinystring.Convert("test 123 test").Replace(123, 456).String()    // out: "test 456 test"

String Splitting & Joining

// Split strings
parts := tinystring.Split("apple,banana,cherry", ",")    
// out: []string{"apple", "banana", "cherry"}

parts := tinystring.Split("hello\tworld\nnew")  // Handles whitespace
// out: []string{"hello", "world", "new"}

// Join slices
tinystring.Convert([]string{"Hello", "World"}).Join().String()    // out: "Hello World"
tinystring.Convert([]string{"a", "b", "c"}).Join("-").String()    // out: "a-b-c"

String Trimming & Cleaning

// Trim operations
tinystring.Convert("  hello  ").Trim().String()                    // out: "hello"
tinystring.Convert("prefix-data").TrimPrefix("prefix-").String()    // out: "data"
tinystring.Convert("file.txt").TrimSuffix(".txt").String()          // out: "file"

// Repeat strings
tinystring.Convert("Go").Repeat(3).String()                        // out: "GoGoGo"

🔢 strconv Package

Replace strconv package functions for type conversions:

Go Standard	TinyString Equivalent
strconv.Itoa()	Convert(i).String()
strconv.Atoi()	Convert(s).ToInt()
strconv.ParseFloat()	Convert(s).ToFloat()
strconv.ParseBool()	Convert(s).ToBool()
strconv.FormatFloat()	Convert(f).RoundDecimals(n).String()
strconv.Quote()	Convert(s).Quote().String()

Type Conversions

// String to numbers
result, err := tinystring.Convert("123").ToInt()        // out: 123, nil
result, err := tinystring.Convert("456").ToUint()       // out: 456, nil  
result, err := tinystring.Convert("3.14").ToFloat()     // out: 3.14, nil

// Numbers to string
tinystring.Convert(42).String()      // out: "42"
tinystring.Convert(3.14159).String() // out: "3.14159"

// Boolean conversions
result, err := tinystring.Convert("true").ToBool()  // out: true, nil
result, err := tinystring.Convert(42).ToBool()      // out: true, nil (non-zero = true)
result, err := tinystring.Convert(0).ToBool()       // out: false, nil

// String quoting
tinystring.Convert("hello").Quote().String()                    // out: "\"hello\""
tinystring.Convert("say \"hello\"").Quote().String()           // out: "\"say \\\"hello\\\"\""

Number Formatting

// Decimal rounding
tinystring.Convert(3.154).RoundDecimals(2).String()           // out: "3.16" (ceiling)
tinystring.Convert(3.154).RoundDecimals(2).Down().String()    // out: "3.15" (floor)

// Number formatting with thousands separator
tinystring.Convert(2189009.00).FormatNumber().String()        // out: "2.189.009"

🖨️ fmt Package

Replace fmt package functions for formatting:

Go Standard	TinyString Equivalent
fmt.Sprintf()	Fmt(format, args...)
fmt.Sprint()	Convert(v).String()

String Formatting

// Printf-style formatting
result := tinystring.Fmt("Hello %s, you have %d messages", "John", 5)
// out: "Hello John, you have 5 messages"

// Multiple format specifiers
result := tinystring.Fmt("Number: %d, Float: %.2f, Bool: %v", 42, 3.14159, true)
// out: "Number: 42, Float: 3.14, Bool: true"

// Advanced formatting (hex, binary, octal)
result := tinystring.Fmt("Hex: %x, Binary: %b, Octal: %o", 255, 10, 8)
// out: "Hex: ff, Binary: 1010, Octal: 10"

❌ errors Package

Replace errors package functions for error handling with multilingual support:

Go Standard	TinyString Equivalent
errors.New()	Err(message)
fmt.Errorf()	Errf(format, args...)

Error Creation

// Simple error creation
err := tinystring.Err("invalid input")
// out: "invalid input"

// Multiple error messages
err := tinystring.Err("invalid format", "expected number")
// out: "invalid format expected number"

// Formatted errors (like fmt.Errorf)
err := tinystring.Errf("invalid value: %s at position %d", "abc", 5)
// out: "invalid value: abc at position 5"

🚀 TinyString Exclusive Features

🌍 Multilingual Error Messages

TinyString includes a comprehensive dictionary system for creating multilingual error messages:

import . "github.com/cdvelop/tinystring"

// Configure default language
OutLang(ES) // Spanish

// Use dictionary words to create error messages
err := Err(D.Invalid, D.Format)
// out: "inválido formato" (Spanish)

// Complex error message composition
err := Err(D.Negative, D.Numbers, D.Not, D.Supported)
// out: "negativo números no soportado" (Spanish)

// Mix languages inline
err := Err(FR, D.Empty, D.String)
// out: "vide chaîne" (French)

// Auto-detect system language
OutLang() // Detects browser/OS language automatically
err := Err(D.Cannot, D.Round, D.NonNumeric, D.Value)
// Output in user's system language

🗣️ Supported Languages

The dictionary system supports 9 languages, prioritized by global reach to ensure optimal binary size.

Core Essential Languages:

• 🇺🇸 EN - English (default)
• 🇪🇸 ES - Spanish
• 🇨🇳 ZH - Chinese
• 🇮🇳 HI - Hindi
• 🇸🇦 AR - Arabic

Extended Reach Languages:

• 🇧🇷 PT - Portuguese
• 🇫🇷 FR - French
• 🇩🇪 DE - German
• 🇷🇺 RU - Russian

📖 Dictionary Words

The dictionary contains essential words for error composition:

// Common error words (alphabetically sorted)
D.Argument    // "argument", "argumento", "argumento", "argument"...
D.Base        // "base", "base", "base", "base"...
D.Cannot      // "cannot", "no puede", "não pode", "ne peut pas"...
D.Empty       // "empty", "vacío", "vazio", "vide"...
D.Format      // "format", "formato", "formato", "format"...
D.Invalid     // "invalid", "inválido", "inválido", "invalide"...
D.Missing     // "missing", "falta", "ausente", "manquant"...
D.Number      // "number", "número", "número", "nombre"...
D.String      // "string", "cadena", "string", "chaîne"...
D.Supported   // "supported", "soportado", "suportado", "pris en charge"...
D.Type        // "type", "tipo", "tipo", "type"...
D.Value       // "value", "valor", "valor", "valeur"...
// ... and more

🎨 Custom Dictionary Extensions

Create your own dictionary words for domain-specific errors:

// Define custom dictionary for your application
type MyDict struct {
    User     LocStr
    Email    LocStr
    Password LocStr
    Login    LocStr
}

// Initialize with translations
var MD = MyDict{
    User: LocStr{
        "user",            // EN
        "usuario",         // ES
        "usuário",         // PT
        "utilisateur",     // FR
        "пользователь",    // RU
        "Benutzer",        // DE
        "utente",          // IT
        "उपयोगकर्ता",      // HI
        "ব্যবহারকারী",     // BN
        "pengguna",        // ID
        "مستخدم",         // AR
        "صارف",           // UR
        "用户",            // ZH
    },
    Email: LocStr{
        "email",           // EN
        "correo",          // ES
        "email",           // PT
        "courriel",        // FR
        "электронная почта", // RU
        "E-Mail",          // DE
        "email",           // IT
        "ईमेल",            // HI
        "ইমেইল",           // BN
        "email",           // ID
        "بريد إلكتروني",   // AR
        "ای میل",          // UR
        "邮箱",            // ZH
    },
    // ... more custom words
}

// Combine system dictionary with custom words
OutLang(ES) // Spanish
err := Err(MD.User, D.Not, D.Found)
// out: "usuario no encontrado"

err := Err(D.Format,MD.Email, D.Invalid) 
// out: "formato correo inválido"

🔧 Language Configuration

// Set specific language
OutLang(ES)    // Spanish
OutLang(FR)    // French
OutLang(ZH)    // Chinese

// Auto-detect system language
OutLang()      // Detects from environment variables (backend) or browser (WASM)

// Override language inline
err := Err(DE, D.Invalid, D.Value)  // Force German
// out: "ungültig Wert"

Features not available in Go's standard library:

🌍 Multilingual Dictionary System

TinyString includes a comprehensive multilingual error system with zero external dependencies:

import . "github.com/cdvelop/tinystring"

// Auto-detect system language or set explicitly
OutLang()    // Auto-detect from environment/browser
OutLang(ES)  // Set Spanish explicitly

// Basic error creation with dictionary words
err := Err(D.Invalid, D.Format)
// out: "inválido formato" (Spanish)

// Complex compositions
err := Err(D.Cannot, D.Round, D.NonNumeric, D.Value)
// out: "no puede redondear no numérico valor" (Spanish)

// Dynamic language switching
err := Err(FR, D.Empty, D.String, D.Not, D.Supported)
// out: "vide chaîne pas pris en charge" (French)

// Mixed with regular strings (backward compatible)
err := Err(D.Invalid, "user input:", "abc123")
// out: "inválido user input: abc123"

// Practical validation example
validateInput := func(input string) error {
    if input == "" {
        return Err(D.Empty, D.String, D.Not, D.Supported)
    }
    if _, err := Convert(input).ToInt(); err != nil {
        return Err(D.Invalid, D.Number, D.Format)
    }
    return nil
}

🎯 Dictionary Features

• 9 Languages: EN, ES, ZH, HI, AR, PT, FR, DE, RU
• 35+ Essential Words: Alphabetically sorted for maximum reusability
• Composable Messages: Build complex errors from simple words
• Zero Dependencies: No external translation libraries
• Auto-Detection: Automatically detects system/browser language
• TinyGo Compatible: Full WebAssembly support

🌍 Unicode & Localization

// Remove accents and diacritics
tinystring.Convert("café naïve résumé").RemoveTilde().String()  // out: "cafe naive resume"
tinystring.Convert("Ñoño niño").RemoveTilde().String()          // out: "Nono nino"

✂️ Smart Truncation

// Basic truncation with ellipsis
tinystring.Convert("Hello, World!").Truncate(10).String()       // out: "Hello, ..."

// Name truncation for UI display
tinystring.Convert("Jeronimo Dominguez").TruncateName(3, 15).String()
// out: "Jer. Dominguez"

// Advanced name handling
tinystring.Convert("Juan Carlos Rodriguez").TruncateName(3, 20).String()
// out: "Jua. Car. Rodriguez"

🔧 Advanced Utilities

// Key-value parsing
value, err := tinystring.ParseKeyValue("user:admin")            // out: "admin", nil
value, err := tinystring.ParseKeyValue("count=42", "=")         // out: "42", nil

// Snake case with custom separators
tinystring.Convert("hello world").ToSnakeCaseLower("-").String() // out: "hello-world"
tinystring.Convert("hello world").ToSnakeCaseUpper("_").String() // out: "HELLO_WORLD"

💡 Performance Tips

Memory Optimization

// ✅ Efficient: Modify original string directly
original := "Él Múrcielago Rápido"
tinystring.Convert(&original).RemoveTilde().ToLower().Apply()
// original is now modified in-place

// ❌ Less efficient: Creates new string
original := "Él Múrcielago Rápido"  
result := tinystring.Convert(original).RemoveTilde().ToLower().String()

Chaining Operations

// Combine multiple operations efficiently
result := tinystring.Convert("  HÓLA MÚNDO  ")
    .Trim()
    .RemoveTilde()
    .ToLower()
    .Replace(" ", "_")
    .String()
// out: "hola_mundo"

🔄 Output Methods: String() vs Apply()

Choose between two approaches for finalizing operations:

// ✅ String() - Returns result, keeps original unchanged
originalText := "Él Múrcielago Rápido"
result := tinystring.Convert(&originalText).RemoveTilde().ToLower().String()
// result: "el murcielago rapido"
// originalText: "Él Múrcielago Rápido" (unchanged)

// ✅ Apply() - Modifies original string directly (memory efficient)
originalText := "Él Múrcielago Rápido"
tinystring.Convert(&originalText).RemoveTilde().ToLower().Apply()
// originalText: "el murcielago rapido" (modified in-place)

Binary Size Comparison

Standard Library Example | TinyString Example

Last updated: 2025-06-23 21:13:50

Build Type	Parameters	Standard Library go build	TinyString tinygo build	Size Reduction	Performance
🖥️ Default Native	-ldflags="-s -w"	1.3 MB	1.1 MB	-177.5 KB	➖ 13.5%
🌐 Default WASM	(default -opt=z)	580.8 KB	242.2 KB	-338.7 KB	✅ 58.3%
🌐 Ultra WASM	-no-debug -panic=trap -scheduler=none -gc=leaking -target wasm	141.3 KB	27.1 KB	-114.1 KB	🏆 80.8%
🌐 Speed WASM	-opt=2 -target wasm	827.0 KB	343.8 KB	-483.2 KB	✅ 58.4%
🌐 Debug WASM	-opt=0 -target wasm	1.8 MB	741.8 KB	-1.1 MB	✅ 59.5%

🎯 Performance Summary

• 🏆 Peak Reduction: 80.8% (Best optimization)
• ✅ Average WebAssembly Reduction: 64.3%
• ✅ Average Native Reduction: 13.5%
• 📦 Total Size Savings: 2.2 MB across all builds

Performance Legend

• ❌ Poor (<5% reduction)
• ➖ Fair (5-15% reduction)
• ✅ Good (15-70% reduction)
• 🏆 Outstanding (>70% reduction)

Memory Usage Comparison

Standard Library Example | TinyString Example

Last updated: 2025-06-24 13:51:51

Performance benchmarks comparing memory allocation patterns between standard Go library and TinyString:

🧪 Benchmark Category	📚 Library	💾 Memory/Op	🔢 Allocs/Op	⏱️ Time/Op	📈 Memory Trend	🎯 Alloc Trend	🏆 Performance
📝 String Processing	📊 Standard	1.2 KB	48	6.1μs	-	-	-
	🚀 TinyString	4.0 KB	189	27.0μs	❌ 237.5% more	❌ 293.8% more	❌ Poor
🔢 Number Processing	📊 Standard	912 B	42	4.7μs	-	-	-
	🚀 TinyString	1.0 KB	105	7.3μs	⚠️ 12.3% more	❌ 150.0% more	❌ Poor
🔄 Mixed Operations	📊 Standard	512 B	26	3.3μs	-	-	-
	🚀 TinyString	1.2 KB	74	8.7μs	❌ 131.3% more	❌ 184.6% more	❌ Poor

🎯 Performance Summary

• 💾 Memory Efficiency: ❌ Poor (Significant overhead) (127.0% average change)
• 🔢 Allocation Efficiency: ❌ Poor (Excessive allocations) (209.5% average change)
• 📊 Benchmarks Analyzed: 3 categories
• 🎯 Optimization Focus: Binary size reduction vs runtime efficiency

⚖️ Trade-offs Analysis

The benchmarks reveal important trade-offs between binary size and runtime performance:

📦 Binary Size Benefits ✅

• 🏆 16-84% smaller compiled binaries
• 🌐 Superior WebAssembly compression ratios
• 🚀 Faster deployment and distribution
• 💾 Lower storage requirements

🧠 Runtime Memory Considerations ⚠️

• 📈 Higher allocation overhead during execution
• 🗑️ Increased GC pressure due to allocation patterns
• ⚡ Trade-off optimizes for distribution size over runtime efficiency
• 🔄 Different optimization strategy than standard library

🎯 Optimization Recommendations

🎯 Use Case	💡 Recommendation	🔧 Best For
🌐 WebAssembly Apps	✅ TinyString	Size-critical web deployment
📱 Embedded Systems	✅ TinyString	Resource-constrained devices
☁️ Edge Computing	✅ TinyString	Fast startup and deployment
🏢 Memory-Intensive Server	⚠️ Standard Library	High-throughput applications
🔄 High-Frequency Processing	⚠️ Standard Library	Performance-critical workloads

📊 Performance Legend

• 🏆 Excellent (Better performance)
• ✅ Good (Acceptable trade-off)
• ⚠️ Caution (Higher resource usage)
• ❌ Poor (Significant overhead)

Contributing

This project is currently being self-financed and developed independently. The development, testing, maintenance, and improvements are funded entirely out of my personal resources and time.

If you find this project useful and would like to support its continued development, you can make a donation here with PayPal. Your support helps cover:

• 💻 Development time and effort
• 🧪 Testing and quality assurance
• 📚 Documentation improvements
• 🔧 Bug fixes and feature enhancements
• 🌐 Community support and maintenance

Any contribution, however small, is greatly appreciated and directly impacts the project's future development. 🙌

License

MIT License

Documentation

Overview

Example (StringPointerBasic)

Estos ejemplos ilustran cómo usar los punteros a strings para evitar asignaciones adicionales

// Creamos una variable string que queremos modificar
myText := "héllô wórld"

// En lugar de crear una nueva variable con el resultado,
// modificamos directamente la variable original usando Apply()
Convert(&myText).RemoveTilde().ToLower().Apply()

// La variable original ha sido modificada
fmt.Println(myText)

Output:

hello world

Example (StringPointerCamelCase)

// Ejemplo de uso con múltiples transformaciones
originalText := "Él Múrcielago Rápido"

// Las transformaciones modifican la variable original directamente
// usando el método Apply() para actualizar el puntero
Convert(&originalText).RemoveTilde().CamelCaseLower().Apply()

fmt.Println(originalText)

Output:

elMurcielagoRapido

Example (StringPointerEfficiency)

// En aplicaciones de alto rendimiento, reducir asignaciones de memoria
// puede ser importante para evitar la presión sobre el garbage collector
// Método tradicional (crea nuevas asignaciones de memoria)
traditionalText := "Texto con ACENTOS"
processedText := Convert(traditionalText).RemoveTilde().ToLower().String()
fmt.Println(processedText)

// Método con punteros (modifica directamente la variable original)
directText := "Otro TEXTO con ACENTOS"
Convert(&directText).RemoveTilde().ToLower().Apply()
fmt.Println(directText)

Output:

texto con acentos
otro texto con acentos

Index

• Constants
• Variables
• func Contains(conv, search string) bool
• func Convert(v ...any) *conv
• func Count(conv, search string) int
• func Err(msgs ...any) *conv
• func Errf(format string, args ...any) *conv
• func Fmt(format string, args ...any) *conv
• func OutLang(l ...lang)
• func ParseKeyValue(in string, delimiters ...string) (value string, err error)
• func Split(data string, separator ...string) (out []string)
• func T(values ...any) string
• type LocStr

Examples

• Package (StringPointerBasic)
• Package (StringPointerCamelCase)
• Package (StringPointerEfficiency)

Constants

const (
	KArray kind = iota
	KBool
	KChan
	KComplex128
	KComplex64
	KErr // Error type (separate from KInvalid)
	KFloat32
	KFloat64
	KFunc
	KInt
	KInt16
	KInt32
	KInt64
	KInt8
	KInterface
	KInvalid
	KMap
	KPointer
	KSlice
	KString
	KSliceStr // Slice of strings
	KStruct
	KUint
	KUint16
	KUint32
	KUint64
	KUint8
	KUintptr
	KUnsafePtr
)

const (
	// Group 1: Core Essential Languages (Maximum Global Reach)
	EN lang = iota // 0 - English (default)
	ES             // 1 - Spanish
	ZH             // 2 - Chinese
	HI             // 3 - Hindi
	AR             // 4 - Arabic

	// Group 2: Extended Reach Languages (Europe & Americas)
	PT // 5 - Portuguese
	FR // 6 - French
	DE // 7 - German
	RU // 8 - Russian

)

Variables

var D = struct {
	// Basic words sorted alphabetically for maximum reusability
	Allowed    LocStr // "allowed"
	Argument   LocStr // "argument"
	At         LocStr // "at"
	Base       LocStr // "base"
	Boolean    LocStr // "boolean"
	Cannot     LocStr // "cannot"
	Character  LocStr // "character"
	Decimal    LocStr // "decimal"
	Delimiter  LocStr // "delimiter"
	Digit      LocStr // "digit"
	Empty      LocStr // "empty"
	End        LocStr // "end"
	Float      LocStr // "float"
	For        LocStr // "for"
	Format     LocStr // "format"
	Found      LocStr // "found"
	In         LocStr // "in"
	Integer    LocStr // "integer"
	Invalid    LocStr // "invalid"
	Missing    LocStr // "missing"
	Negative   LocStr // "negative"
	NonNumeric LocStr // "non-numeric"
	Not        LocStr // "not"
	Number     LocStr // "number"
	Numbers    LocStr // "numbers"
	Of         LocStr // "of"
	Out        LocStr // "out"
	Overflow   LocStr // "overflow"
	Range      LocStr // "range"
	Required   LocStr // "required"
	Round      LocStr // "round"
	Specifier  LocStr // "specifier"
	String     LocStr // "string"
	Supported  LocStr // "supported"
	Type       LocStr // "type"
	Unknown    LocStr // "unknown"
	Unsigned   LocStr // "unsigned"
	Value      LocStr // "value"
}{
	Allowed:    LocStr{"allowed", "permitido", "允许", "अनुमति", "مسموح", "permitido", "autorisé", "erlaubt", "разрешено"},
	Argument:   LocStr{"argument", "argumento", "参数", "तर्क", "وسيط", "argumento", "argument", "Argument", "аргумент"},
	At:         LocStr{"at", "en", "在", "पर", "في", "em", "à", "bei", "в"},
	Base:       LocStr{"base", "base", "进制", "आधार", "قاعدة", "base", "base", "Basis", "основание"},
	Boolean:    LocStr{"boolean", "booleano", "布尔", "बूलियन", "منطقي", "booleano", "booléen", "boolescher", "логический"},
	Cannot:     LocStr{"cannot", "no puede", "不能", "नहीं कर सकते", "لا يمكن", "não pode", "ne peut pas", "kann nicht", "не может"},
	Character:  LocStr{"character", "caracter", "字符", "वर्ण", "حرف", "caractere", "caractère", "Zeichen", "символ"},
	Decimal:    LocStr{"decimal", "decimal", "十进制", "दशमलव", "عشري", "decimal", "décimal", "Dezimal", "десятичная"},
	Delimiter:  LocStr{"delimiter", "delimitador", "分隔符", "सीमांकक", "محدد", "delimitador", "délimiteur", "Trennzeichen", "разделитель"},
	Digit:      LocStr{"digit", "dígito", "数字", "अंक", "رقم", "dígito", "chiffre", "Ziffer", "цифра"},
	Empty:      LocStr{"empty", "vacío", "空", "खाली", "فارغ", "vazio", "vide", "leer", "пустой"},
	End:        LocStr{"end", "fin", "结束", "अंत", "نهاية", "fim", "fin", "Ende", "конец"},
	Float:      LocStr{"float", "flotante", "浮点", "फ्लोट", "عائم", "flutuante", "flottant", "Gleitkomma", "число с плавающей точкой"},
	For:        LocStr{"for", "para", "为", "के लिए", "لـ", "para", "pour", "für", "для"},
	Format:     LocStr{"format", "formato", "格式", "प्रारूप", "تنسيق", "formato", "format", "Fmt", "формат"},
	Found:      LocStr{"found", "encontrado", "找到", "मिला", "موجود", "encontrado", "trouvé", "gefunden", "найден"},
	Integer:    LocStr{"integer", "entero", "整数", "पूर्णांक", "عدد صحيح", "inteiro", "entier", "ganze Zahl", "целое число"},
	Invalid:    LocStr{"invalid", "inválido", "无效", "अमान्य", "غير صالح", "inválido", "invalide", "ungültig", "недопустимый"},
	Missing:    LocStr{"missing", "falta", "缺少", "गुम", "مفقود", "ausente", "manquant", "fehlend", "отсутствует"},
	Negative:   LocStr{"negative", "negativo", "负", "नकारात्मक", "سالب", "negativo", "négatif", "negativ", "отрицательный"},
	NonNumeric: LocStr{"non-numeric", "no numérico", "非数字", "गैर-संख्यात्मक", "غير رقمي", "não numérico", "non numérique", "nicht numerisch", "нечисловой"},
	Not:        LocStr{"not", "no", "不", "नहीं", "ليس", "não", "pas", "nicht", "не"},
	Number:     LocStr{"number", "número", "数字", "संख्या", "رقم", "número", "nombre", "Zahl", "число"},
	Numbers:    LocStr{"numbers", "números", "数字", "संख्याएं", "أرقام", "números", "nombres", "Zahlen", "числа"},
	Of:         LocStr{"of", "de", "的", "का", "من", "de", "de", "von", "из"},
	Out:        LocStr{"out", "fuera", "出", "बाहर", "خارج", "fora", "hors", "aus", "вне"},
	Overflow:   LocStr{"overflow", "desbordamiento", "溢出", "ओवरफ्लो", "فيض", "estouro", "débordement", "Überlauf", "переполнение"},
	Range:      LocStr{"range", "rango", "范围", "रेंज", "نطاق", "intervalo", "plage", "Bereich", "диапазон"},
	Required:   LocStr{"required", "requerido", "必需", "आवश्यक", "مطلوب", "necessário", "requis", "erforderlich", "обязательный"},
	Round:      LocStr{"round", "redondear", "圆", "गोल", "جولة", "arredondar", "arrondir", "runden", "округлить"},
	Specifier:  LocStr{"specifier", "especificador", "说明符", "निर्दिष्टकर्ता", "محدد", "especificador", "spécificateur", "Spezifizierer", "спецификатор"},
	String:     LocStr{"string", "cadena", "字符串", "स्ट्रिंग", "سلسلة", "string", "chaîne", "Zeichenkette", "строка"},
	Supported:  LocStr{"supported", "soportado", "支持", "समर्थित", "مدعوم", "suportado", "pris en charge", "unterstützt", "поддерживается"},
	Type:       LocStr{"type", "tipo", "类型", "प्रकार", "نوع", "tipo", "type", "Typ", "тип"},
	Unknown:    LocStr{"unknown", "desconocido", "未知", "अज्ञात", "غير معروف", "desconhecido", "inconnu", "unbekannt", "неизвестный"},
	Unsigned:   LocStr{"unsigned", "sin signo", "无符号", "अहस्ताक्षरित", "غير موقع", "sem sinal", "non signé", "vorzeichenlos", "безzнаковый"},
	Value:      LocStr{"value", "valor", "值", "मूल्य", "قيمة", "valor", "valeur", "Wert", "значение"},
}

Global dictionary instance - populated with all translations using horizontal format Language order: EN, ES, ZH, HI, AR, PT, FR, DE, RU

By using an anonymous struct, we define and initialize the dictionary in a single step, avoiding the need for a separate 'type dictionary struct' declaration. The usage API (e.g., D.Argument) remains unchanged.

Functions

func Contains

func Contains(conv, search string) bool

Contains checks if the string 'search' is present in 'conv' Returns true if found, false otherwise This matches the behavior of the standard library strings.Contains

func Convert

func Convert(v ...any) *conv

Convert initializes a new conv struct with optional value for string,bool and number manipulation. REFACTORED: Now accepts variadic parameters - Convert() or Convert(value) Phase 7: Uses object pool internally for memory optimization (transparent to user)

func Count

func Count(conv, search string) int

Count checks how many times the string 'search' is present in 'conv' eg: "hello world" with search "world" will return 1

func Err

func Err(msgs ...any) *conv

func Errf

func Errf(format string, args ...any) *conv

Errf creates a new conv instance with error formatting similar to fmt.Errf Example: tinystring.Errf("invalid value: %s", value).Error()

func Fmt

func Fmt(format string, args ...any) *conv

Fmt formats a string using a printf-style format string and arguments. Example: Fmt("Hello %s", "world") returns "Hello world"

func OutLang

func OutLang(l ...lang)

OutLang sets the default output language OutLang() without parameters auto-detects system language OutLang(ES) sets Spanish as default

func ParseKeyValue

func ParseKeyValue(in string, delimiters ...string) (value string, err error)

ParseKeyValue extracts the value part from a "key:value" formatted string. By default, it uses ":" as the delimiter but accepts an optional custom delimiter. The function returns the value part and an error (nil if successful).

Examples:

value, err := ParseKeyValue("name:John")
// value = "John", err = nil

value, err := ParseKeyValue("data=123", "=")
// value = "123", err = nil

value, err := ParseKeyValue("invalid-string")
// value = "", err = error containing "delimiter ':' not found in string invalid-string"

func Split

func Split(data string, separator ...string) (out []string)

func T

func T(values ...any) string

T creates a translated string with support for multilingual translations Same functionality as Err but returns string directly instead of *conv This function is used internally by the builder API for efficient string construction

Usage examples: T(D.Format, D.Invalid) returns "invalid format" T(ES, D.Format, D.Invalid) returns "formato inválido"

Types

type LocStr

type LocStr [9]string

LocStr represents a string with translations for multiple languages.

It is a fixed-size array where each index corresponds to a language constant (EN, ES, PT, etc.). This design ensures type safety and efficiency, as the compiler can verify that all translations are provided.

The order of translations must match the order of the language constants.

Example of creating a new translatable term for "File":

var MyDictionary = struct {
	File LocStr
}{
	File: LocStr{
		EN: "file",
		ES: "archivo",
		ZH: "文件",
		HI: "फ़ाइल",
		AR: "ملف",
		PT: "arquivo",
		FR: "fichier",
		DE: "Datei",
		RU: "файл",
	},
}

Usage in code:

err := Err(MyDictionary.File, D.Not, D.Found) // -> "file not found", "archivo no encontrado", etc.