ko

ko is a small lodash-style helper package for Go collection chains.

It focuses on direct, type-safe helpers for slices and maps. There are no runtime dependencies outside the Go standard library.

go get github.com/go-kod/ko

ko currently targets Go 1.27, matching the module's go.mod.

Start with ko.Slice, ko.Of, ko.Range, ko.RangeStep, or ko.FromChannel, chain operations on ko.Seq[T], then call Collect for the final slice. Seq[T] is iterator-backed and can be ranged directly or converted to iter.Seq[T] for standard helpers such as slices.Collect.

got := ko.Of(1, 2, 3, 4).
	Filter(func(item int, _ int) bool {
		return item%2 == 0
	}).
	Map(func(item int, _ int) string {
		return strconv.Itoa(item * 10)
	}).
	Collect()

// []string{"20", "40"}

Seq methods:

Chunk and Window return unexported adapter types. They can be ranged directly, collected to [][]T, or mapped as []T values without naming the adapter type.

sums := ko.Slice([]int{1, 2, 3, 4}).Chunk(2).
	Map(func(chunk []int, _ int) int {
		return chunk[0] + chunk[1]
	}).
	Collect()

// []int{3, 7}

Window advances by step; use step == 1 for sliding windows that overlap by one item.

Use ToMap or Enumerate when a Seq should become Seq2. GroupBy returns an unexported grouped adapter whose grouped values are slices; grouped keys are yielded in first-seen order.

byLength := ko.Slice([]string{"go", "ko", "kod"}).
	GroupBy(func(item string, _ int) int {
		return len(item)
	}).
	Collect()

// map[int][]string{2: {"go", "ko"}, 3: {"kod"}}

Start with ko.Map, chain operations, then call Collect for the final map. Seq2[K, V] can also be converted to iter.Seq2[K, V] for standard helpers such as maps.Collect.

got := ko.Map(map[string]int{"a": 1, "bb": 2}).
	Filter(func(_ string, value int) bool {
		return value > 1
	}).
	Map(func(key string, value int) (int, string) {
		return len(key), strconv.Itoa(value)
	}).
	Collect()

// map[int]string{2: "2"}

Seq2 methods:

• Predicates and mappers receive the item plus its index for slices.
• Slice accepts any element type. Use DistinctBy to remove duplicates by a comparable key.
• Seq2 is an entry stream; duplicate key replacement happens when Collect materializes a Go map.
• Map predicates and mappers receive key and value.
• Map iteration order follows Go map iteration order, so sort ToSlice output in tests when order matters.
• Chain methods that transform collections return iterable chains; Collect materializes the current collection.
• FromChannel is one-shot because it drains the source channel as it is consumed.
• Methods that need suffix, sort, reverse, or whole-sequence knowledge buffer only when consumed, such as Sort, SortBy, Reverse, negative Nth, TakeRight, DropRight, and grouping.
• This package intentionally stays small. Prefer Go's standard library when it already covers the job.

go test ./...
go test -cover ./...
/home/pilot/sdk/go1.27rc1/bin/gofmt -w *.go

Format Go files with the Go toolchain declared in go.mod; older gofmt binaries do not parse Go 1.27 generic methods.