parallel.go.template

// vim: ft=go

// parallel_template.go
// Pipe mode with concurrent goroutine processing.
// Magic variables available in the loop body:
//   x / line  - current line (string)
//   i / idx   - loop index (int)
//   f / fields - split fields of x ([]string)
// Always available:
//   lines     - all stdin lines ([]string)
//
// NOTE: output order is NOT guaranteed — lines may interleave.

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"os"
	"strconv"
	"strings"
	"sync"
)

// ---- helpers ----

// die prints err to stderr and exits 1. No-op if err is nil.
func die(err error) {
	if err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(1)
	}
}

// must unwraps a (value, error) pair, calling die on error.
//
//	n, err := strconv.Atoi(s)   →   n := must(strconv.Atoi(s))
func must[T any](v T, err error) T {
	die(err)
	return v
}

// atoi parses s as an int. Exits on failure.
func atoi(s string) int { return must(strconv.Atoi(strings.TrimSpace(s))) }

// atof parses s as a float64. Exits on failure.
func atof(s string) float64 { return must(strconv.ParseFloat(strings.TrimSpace(s), 64)) }

// pp returns v formatted as indented JSON (falls back to %+v on error).
// Used with auto-print: pp(myMap) prints the JSON automatically.
func pp(v any) string {
	b, err := json.MarshalIndent(v, "", "  ")
	if err != nil {
		return fmt.Sprintf("%+v", v)
	}
	return string(b)
}

// trim returns strings.TrimSpace(s).
func trim(s string) string { return strings.TrimSpace(s) }

// splitlines splits a multi-line string into a slice, dropping the trailing newline.
func splitlines(s string) []string { return strings.Split(strings.TrimRight(s, "\n"), "\n") }

var _reCache sync.Map

func _reCached(pat string) *regexp.Regexp {
	if v, ok := _reCache.Load(pat); ok {
		return v.(*regexp.Regexp)
	}
	r := regexp.MustCompile(pat)
	_reCache.Store(pat, r)
	return r
}

// match returns submatches: [0]=full match, [1+]=capture groups. nil if no match.
func match(pat, s string) []string { return _reCached(pat).FindStringSubmatch(s) }

// named returns named capture groups as a map. nil if no match.
func named(pat, s string) map[string]string {
	r := _reCached(pat)
	m := r.FindStringSubmatch(s)
	if m == nil {
		return nil
	}
	result := map[string]string{}
	for i, name := range r.SubexpNames() {
		if name != "" && i < len(m) {
			result[name] = m[i]
		}
	}
	return result
}

// ---- end helpers ----

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
	var lines []string
	for scanner.Scan() {
		lines = append(lines, scanner.Text())
	}
	_ = lines

	// {{PIPE_BEFORE}}

	var wg sync.WaitGroup
	sem := make(chan struct{}, {{PARALLEL_N}})

	for i, x := range lines {
		wg.Add(1)
		sem <- struct{}{}
		go func(i int, x string) {
			defer wg.Done()
			defer func() { <-sem }()
			line := x
			idx := i
			f := {{FIELDS_EXPR}}
			fields := f
			_ = line; _ = idx; _ = f; _ = fields
			// {{PIPE_BODY}}
		}(i, x)
	}

	wg.Wait()
}