@batch Operator in TuskLang - Go Guide

🔄 Batch Power: @batch Operator Unleashed

TuskLang's @batch operator is your concurrency rebellion. We don't bow to any king—especially not to slow, sequential processing. Here's how to use @batch in Go projects to process data in parallel, optimize performance, and handle large-scale operations.

📋 Table of Contents

- What is @batch? - Basic Usage - Batch Operations - Parallel Processing - Go Integration - Best Practices

🔄 What is @batch?

The @batch operator processes multiple operations in parallel, optimizing performance and resource utilization. No more sequential bottlenecks—just pure, parallel power.

🛠️ Basic Usage

[batch_processing]
files: @batch.parse(["config1.tsk", "config2.tsk", "config3.tsk"])
queries: @batch.query(["SELECT  FROM users", "SELECT  FROM orders"])
requests: @batch.http(["GET", "https://api1.com", "https://api2.com"])

🔧 Batch Operations

File Processing

[files]
configs: @batch.parse(["main.tsk", "db.tsk", "cache.tsk"])
templates: @batch.read(["template1.html", "template2.html"])
logs: @batch.process(["app.log", "error.log", "access.log"])

Database Operations

[database]
user_data: @batch.query([
    "SELECT * FROM users WHERE active = true",
    "SELECT * FROM user_profiles",
    "SELECT * FROM user_preferences"
])
stats: @batch.query([
    "SELECT COUNT(*) FROM users",
    "SELECT COUNT(*) FROM orders",
    "SELECT COUNT(*) FROM products"
])

HTTP Requests

[external]
status_checks: @batch.http([
    ["GET", "https://api1.com/health"],
    ["GET", "https://api2.com/status"],
    ["GET", "https://api3.com/ping"]
])
data_fetch: @batch.http([
    ["GET", "https://api1.com/users"],
    ["GET", "https://api2.com/orders"],
    ["GET", "https://api3.com/products"]
])

⚡ Parallel Processing

[parallel]
workers: 4
timeout: "30s"
results: @batch.parallel([
    @query("SELECT * FROM large_table_1"),
    @query("SELECT * FROM large_table_2"),
    @query("SELECT * FROM large_table_3"),
    @query("SELECT * FROM large_table_4")
], workers, timeout)

🔗 Go Integration

// Access batch results
configs := config.GetArray("configs")
userData := config.GetArray("user_data")
statusChecks := config.GetArray("status_checks")
// Process batch results
for i, result := range configs {
    fmt.Printf("Config %d: %v\n", i, result)
}

Manual Batch Processing

func ProcessBatch(items []string, processor func(string) error) error {
    var wg sync.WaitGroup
    errors := make(chan error, len(items))
    
    for _, item := range items {
        wg.Add(1)
        go func(item string) {
            defer wg.Done()
            if err := processor(item); err != nil {
                errors <- err
            }
        }(item)
    }
    
    wg.Wait()
    close(errors)
    
    for err := range errors {
        if err != nil {
            return err
        }
    }
    
    return nil
}

🥇 Best Practices

- Use appropriate batch sizes for your resources - Implement error handling for batch failures - Monitor memory usage during batch operations - Use timeouts to prevent hanging operations - Consider rate limiting for external APIs

---

TuskLang: Parallel power with @batch.