- Add Intersperse: inserts separator between each element
- Pre-allocated for optimal performance
- Comprehensive tests including edge cases
- Benchmark included
Example: Intersperse([1,2,3], 0) → [1,0,2,0,3]
Resolves Issue 18
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Mark Issue 12 (Add Stress Tests) as completed with commit hash 6576c4f.
Update overall progress to 10/25 issues completed.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
- Add large data tests (1M elements) for Filter, Map, Partition, Unique
- Add concurrency stress tests with high worker counts (50-100)
- Add race condition tests with 100 iterations
- Add concurrent function call tests (10 goroutines)
- Add context cancellation tests for ParallelMap
- All tests skip in short mode to keep CI fast
All tests pass including race detector validation.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Fixes useless capacity hint of 0 for map initialization.
Uses estimated capacity of len(values)/10 to reduce map
resizing operations.
Changes:
- Before: make(map[K][]V, 0) - capacity 0 is meaningless for maps
- After: make(map[K][]V, len(values)/10) - reasonable estimate
Impact:
- Reduces map resizing overhead during population
- Assumes ~10% unique keys (reasonable for grouping operations)
- May over-allocate for high cardinality, but acceptable trade-off
This is a minor optimization that avoids repeated map growth
when keys are added.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Pre-allocates result slice with estimated capacity to reduce
repeated allocations during append operations.
Strategy:
- Estimates capacity as len(values) * 2
- Assumes average of 2-3 items per mapped element
- Simple heuristic that works well for typical use cases
Performance improvements:
- Time: 907.4 ns/op → 616.7 ns/op (32% faster)
- Memory: 6,120 B/op → 4,992 B/op (18% less)
- Allocations: 8 → 2 (75% reduction)
Impact:
- Significantly reduces allocation overhead
- Better performance for typical flatmap operations
- May over-allocate if mapper returns <2 items on average
Added BenchmarkFlatmap to track performance.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Adds performance benchmarks for core collection functions to enable
tracking of performance regressions and optimization opportunities.
Benchmarks added:
- Map: 1000 element transformation
- Reduce: 1000 element sum
- Partition: 1000 element split
- Unique/UniqueInPlace: Comparison with many duplicates
- ParallelMap: Multiple worker counts (1, 2, 4, 8)
- MapVsParallelMap: Direct comparison (10k elements)
Key findings from benchmarks:
- Map: 1363 ns/op, 1 alloc (excellent)
- Reduce: 335 ns/op, 0 allocs (excellent)
- Partition: 3411 ns/op, 2 allocs (good - both slices)
- ParallelMap overhead: ~240x slower for simple operations
- ParallelMap is best for CPU-intensive operations (>1ms per element)
Use cases clarified:
- Regular Map for simple/fast operations
- ParallelMap for expensive operations with 100+ elements
- Optimal workers: 1-4 for most workloads
All tests pass ✅
Coverage maintained ✅🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
BREAKING CHANGE: Drop function now correctly drops first N elements
instead of removing element at specific index.
Changes:
- Renamed old Drop behavior to RemoveAt function
- Implemented correct Drop semantics (drop first N elements)
- Added comprehensive tests for both functions
Drop (NEW behavior):
- Drop([]int{1,2,3,4,5}, 2) → [3,4,5] (drops first 2 elements)
- Returns empty slice if n >= len(values)
- Returns original slice if n <= 0
RemoveAt (OLD Drop behavior):
- RemoveAt([]int{1,2,3,4,5}, 2) → [1,2,4,5] (removes index 2)
- Returns original slice if index out of bounds
- Pre-allocates with capacity len(values)-1
Tests added:
- Drop: 5 tests (basic, none, all, empty, single)
- RemoveAt: 6 tests (basic, first, last, bounds, empty, single)
Documentation updated:
- README.md: Added RemoveAt to function list
- CLAUDE.md: Marked Drop semantics as fixed
- ACTION_PLAN.md: Updated completion status
Migration guide:
- Old: Drop(slice, index) → New: RemoveAt(slice, index)
- New Drop usage: Drop(slice, n) drops first n elements
Coverage: 98.8% (maintained)
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Adds extensive edge case tests for core functions to catch
regressions and ensure robust behavior.
Test coverage added:
- Empty slice tests: Filter, Map, Partition, Reduce, Unique, Last
- Single element tests: Filter, Map, Partition, Reduce, Unique, Last
- Large dataset tests: Filter (10k), Map (10k)
- Boundary cases: Partition (all pass/reject), Unique (no dups/all same)
Functions tested:
- Filter: 4 new tests (empty, single, single no match, large)
- Partition: 4 new tests (empty, single, all pass, all reject)
- Last: 2 new tests (empty panic, single element)
- Map: 3 new tests (empty, single, large)
- Unique: 4 new tests (empty, single, no dups, all same)
- Reduce: 2 new tests (empty, single)
Results:
- All 118 tests pass
- Coverage: 98.4% (maintained high coverage)
- Verified panic behavior for edge cases
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Adds length checks to Max and Min functions to provide clear,
explicit panic messages when called with empty slices, rather
than allowing confusing index-out-of-bounds panics.
Changes:
- Max: Added check for empty slice with "underscore.Max: empty slice" panic
- Min: Added check for empty slice with "underscore.Min: empty slice" panic
- Updated doc comments to document panic behavior
- Added TestMaxEmpty and TestMinEmpty to verify panic behavior
Impact:
- Better error messages for debugging
- Documented behavior prevents user surprises
- Non-breaking change (still panics, just with clearer message)
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Adds capacity hints to both keep and reject slices in Partition
function to prevent repeated allocations during append operations.
Changes:
- keep: make([]T, 0) → make([]T, 0, len(values))
- reject: make([]T, 0) → make([]T, 0, len(values))
Impact:
- Reduces allocations from O(log n) to O(1) for each slice
- Improves performance by eliminating slice growth overhead
- Minimal memory overhead as worst case is original slice size
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Replaces O(n²) bubble sort algorithm with O(n log n) slices.SortFunc
from the standard library, delivering massive performance improvements.
Performance improvements:
- Large dataset (1000 items): 2,121,531 ns/op → 3,372 ns/op (629x faster!)
- Small dataset (10 items): 199 ns/op → 178 ns/op (10% faster)
- Time reduction: 99.84% for large datasets
Resolves the TODO comment about replacing the simple algorithm.
Also adds comprehensive benchmarks for both small and large datasets
to track performance regressions.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Improves Filter performance by pre-allocating result slice with
input capacity instead of growing dynamically.
Performance improvements:
- Time: 1867 ns/op → 1717 ns/op (8% faster)
- Allocations: 10 → 1 (90% reduction)
This significantly reduces GC pressure for high-frequency operations.
Also updates Join test to expect empty slice [] instead of nil,
which is better Go practice.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Update README to use the latest version in install instructions, expand
the
list of available API functions, and add documentation for new utilities
and
subpackages. Improves clarity and completeness for users.
Replace usage of golang.org/x/exp/constraints with Go 1.22 cmp/slices.
Update .golangci.yml to new v2 format and enable gofmt/goimports.
Refactor imports and type constraints across codebase for consistency.
Add tests to verify default worker behavior in ParallelMap and
ParallelFilter.
Add internal test to cover unexported Result marker methods for
coverage.
Add `ParallelFilter` for concurrent filtering with context and error
support.
Add `UniqueInPlace` to remove duplicates from slices in place. Update
README
and add documentation and tests for both functions.
- Add `Chunk` to split slices into groups of size n.
- Add `ContainsBy` for predicate-based containment checks.
- Add `UniqueBy` to deduplicate slices by key selector.
- Add `ParallelMap` for concurrent mapping with context and error
handling.
- Add `maps.Keys` and `maps.Values` helpers for extracting map
keys/values.
- Update README and docs for new features.
- Refactor `Contains` to use `slices.Contains`.
* Adding some new funky functions which I find useful
Created a Tuple struct as some of the new functions require you to return a new slice with two fields which is the result of the new functions
Created the Join, JoinProjection, Range, SumMap, Zip functions, ecah fuction is documented with how it works and had a unit test or maybe more
* Added in an OrderBy function
* Documentation comment for OrderBy which I missed out
* Adding a Unit test for JoinProject function
Updated the comments on the Join & OrderBy functions so they make a little more sense.
Covered an extra test case with the Join test, where the left set has more data than the right and so the Right handside array of the join is empty
* Adding a count method to the package, so you can find out how many items in a slice satisfy and given condition
* Updating count to work with any so you can count structs as well as basic types
* Removing extra underscores
* Adding some new funky functions which I find useful
Created a Tuple struct as some of the new functions require you to return a new slice with two fields which is the result of the new functions
Created the Join, JoinProjection, Range, SumMap, Zip functions, ecah fuction is documented with how it works and had a unit test or maybe more
* Added in an OrderBy function
* Documentation comment for OrderBy which I missed out
* Adding a Unit test for JoinProject function
Updated the comments on the Join & OrderBy functions so they make a little more sense.
Covered an extra test case with the Join test, where the left set has more data than the right and so the Right handside array of the join is empty
* Adding a count method to the package, so you can find out how many items in a slice satisfy and given condition
* Adding some new funky functions which I find useful
Created a Tuple struct as some of the new functions require you to return a new slice with two fields which is the result of the new functions
Created the Join, JoinProjection, Range, SumMap, Zip functions, ecah fuction is documented with how it works and had a unit test or maybe more
* Added in an OrderBy function
* Documentation comment for OrderBy which I missed out
* Adding a Unit test for JoinProject function
Updated the comments on the Join & OrderBy functions so they make a little more sense.
Covered an extra test case with the Join test, where the left set has more data than the right and so the Right handside array of the join is empty
