rust-lodash 0.1.0

A high-performance, type-safe Rust implementation of Lodash collection methods with zero-cost abstractions
Documentation

rust-lodash

Crates.io Documentation License: MIT CI

A high-performance, type-safe Rust implementation of Lodash collection methods with zero-cost abstractions.

Features

  • 🚀 High Performance: Zero-cost abstractions with optimized implementations
  • 🔒 Type Safety: Full compile-time type checking and memory safety
  • 🔗 Chainable API: Fluent interface for method chaining
  • ⚡ Async Support: Optional async/await support for modern Rust
  • 🔄 Parallel Processing: Optional parallel iteration with rayon
  • 🌐 WASM Compatible: Full WebAssembly support for browser usage
  • 📦 No Std Support: Optional no_std support for embedded systems

Quick Start

Add this to your Cargo.toml:

[dependencies]

rust-lodash = "0.1.0"

Basic Usage

use rust_lodash::prelude::*;

// Basic operations
let doubled = map(&[1, 2, 3, 4], |x| x * 2);
assert_eq!(doubled, vec![2, 4, 6, 8]);

// Chainable operations
let result = chain(&[1, 2, 3, 4, 5])
    .filter(|x| x % 2 == 0)
    .map(|x| x * 3)
    .collect();
assert_eq!(result, vec![6, 12]);

// Collection operations
let numbers = vec![1, 2, 3, 4, 5];
let evens = filter(&numbers, |x| x % 2 == 0);
let sum = reduce(&numbers, |acc, x| acc + x, 0);

Advanced Features

Async Support (Optional)

[dependencies]

rust-lodash = { version = "0.1.0", features = ["async"] }


use rust_lodash::prelude::*;

// Async operations (requires async feature)
// let async_result = map_async(&[1, 2, 3], |x| async move { x * 2 }).await;
// assert_eq!(async_result, vec![2, 4, 6]);

Parallel Processing (Optional)

[dependencies]

rust-lodash = { version = "0.1.0", features = ["parallel"] }


use rust_lodash::prelude::*;

// Parallel operations (requires parallel feature)
// let result = map_parallel(&[1, 2, 3, 4], |x| x * 2);
// assert_eq!(result, vec![2, 4, 6, 8]);

WASM Support (Optional)

[dependencies]

rust-lodash = { version = "0.1.0", features = ["wasm"] }

API Reference

Collection Operations

Iteration

  • map(collection, iteratee) - Transform each element
  • filter(collection, predicate) - Filter elements by condition
  • reduce(collection, iteratee, initial) - Reduce to single value
  • forEach(collection, iteratee) - Execute function for each element
  • forEachRight(collection, iteratee) - Execute function from right to left

Query

  • find(collection, predicate) - Find first matching element
  • findLast(collection, predicate) - Find last matching element
  • includes(collection, value) - Check if value exists
  • every(collection, predicate) - Check if all elements match
  • some(collection, predicate) - Check if any element matches
  • countBy(collection, iteratee) - Count elements by key
  • partition(collection, predicate) - Split into two groups

Transform

  • groupBy(collection, iteratee) - Group elements by key
  • keyBy(collection, iteratee) - Create object with keys
  • sortBy(collection, iteratee) - Sort elements by key
  • orderBy(collection, iteratee, descending) - Sort with direction
  • invoke(collection, method) - Invoke method on each element

Operations

  • shuffle(collection) - Randomize element order
  • sample(collection) - Get random element
  • sampleSize(collection, n) - Get n random elements
  • size(collection) - Get collection length

Chain API

use rust_lodash::chain;

let result = chain(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    .filter(|x| x % 2 == 0)    // [2, 4, 6, 8, 10]
    .map(|x| x * 3)            // [6, 12, 18, 24, 30]
    .take(3)                   // [6, 12, 18]
    .reverse()                 // [18, 12, 6]
    .collect();                // Vec<i32>

Examples

See the examples/ directory for more detailed usage examples:

  • basic_usage.rs - Comprehensive examples of all features
  • standalone_test.rs - Simple functionality test

Performance

lodash-rs is designed for high performance:

  • Zero-cost abstractions: No runtime overhead for method chaining
  • Optimized algorithms: Efficient implementations of all operations
  • Memory efficient: Minimal allocations and copying
  • SIMD ready: Prepared for future SIMD optimizations

Compatibility

  • Rust: 1.70+
  • Platforms: Windows, macOS, Linux
  • Architectures: x86_64, ARM64
  • WASM: Full browser support

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for details.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

  • Inspired by the original Lodash JavaScript library
  • Built with modern Rust best practices
  • Community feedback and contributions

Changelog

See CHANGELOG.md for a detailed list of changes.

Roadmap

  • Additional collection methods
  • Performance benchmarks
  • SIMD optimizations
  • More async operations
  • Enhanced WASM bindings
  • Documentation improvements