internal

type Aggregation = GAggregation[any, any]

type Aggregator = GAggregator[any, any]

type Chain interface {
	Map(Mapper, ...string) Chain
	Explode(Exploder, ...string) Chain
	ExplodeByFactory(ExploderFactory, ...string) Chain
	Filter(Filter, ...string) Chain
	Sort(CompareFunc, ...string) Chain
	Transform(Transformer, ...string) Chain
	Aggregate(Aggregator, ...string) Chain
	Sequential(untypedChain Chain, name ...string) Chain
	Parallel(untypedChain Chain, processing processing.Processing, name ...string) Chain
	Stable(untypedChain Chain, processing processing.Processing, name ...string) Chain
	Conditional(c Condition, untypedChain Chain, name ...string) Chain
	Add(n Chain, name ...string) Chain
	Step(s Step) Chain

	Execute(ctx context.Context, seq iter.Seq[any], name ...string) iter.Seq[any]
	ExecuteWithConfig(ctx context.Context, cfg any, seq iter.Seq[any], name ...string) iter.Seq[any]
	// contains filtered or unexported methods
}

type CompareFunc = func(a, b any) int

type Condition func(context.Context) bool

type Exploder = GExploder[any, any]

type ExploderFactory = GExploderFactory[any, any]

type Filter = GFilter[any]

type GAggregation[I, O any] interface {
	// Aggregate consumes one element and optionally provides a set of new
	// elements based on the previously consumed set of elements. If called
	// in a parallel chain, the implementation must potentially be synchronized.
	Aggregate(I) []O
	// Finish must finally provide new elements based on the actual internal
	// state. It is called, after the last element has been propagated.
	Finish() []O
}

type GAggregator[I, O any] = func() GAggregation[I, O]

type GExploder[I, O any] func(I) []O

type GExploderFactory[I, O any] func(context.Context) GExploder[I, O]

type GFilter[I any] func(I) bool

type GMapper[I, O any] = func(I) O

type Mapper = GMapper[any, any]

type Step interface {
	String() string
	GetName() string
	Renamed(name string) Step
	// contains filtered or unexported methods
}

type Transformer = func(a []any) []any