Crate rinq 

rinq — Rust Integrated Query

A type-safe, zero-cost LINQ-inspired query engine for Rust.

rinq lets you compose filter → sort → aggregate pipelines over any in-memory collection using a fluent builder API. The type-state pattern encodes the valid operation order at compile time, so invalid chains (e.g. calling order_by after select) are rejected without runtime overhead.

Quick Start

use rinq::QueryBuilder;

let total: i32 = QueryBuilder::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    .where_(|x| x % 2 == 0)   // keep evens
    .order_by(|x| *x)          // sort ascending
    .sum();                    // terminal — evaluates the pipeline

assert_eq!(total, 30);

State Machine

Every QueryBuilder<T, State> carries a compile-time state that restricts which methods are available:

State	Available transitions
Initial	where_, take, skip, flat_map, order_by, group_by, …
Filtered	same as Initial plus select
Sorted	then_by, then_by_descending, plus all terminal ops
Projected<U>	collect() only

Feature Flags

Feature	What it enables
parallel	ParallelQueryBuilder via rayon
serde	QueryBuilder::from_json deserialization via serde_json

Enable features in your Cargo.toml:

[dependencies]
rinq = { version = "3", features = ["parallel", "serde"] }

Statistical Extensions

For descriptive statistics, correlation, regression, sampling, and validation, see the companion crate rinq-stats.

Re-exports

pub use core::builder::IntoQuery;

pub use core::builder::QueryBuilder;

pub use core::builder::Queryable;

pub use core::error::RinqError;

pub use core::error::RinqResult;

pub use core::state::Filtered;

pub use core::state::Initial;

pub use core::state::Projected;

pub use core::state::Sorted;

pub use core::try_builder::TryQueryBuilder;

pub use metrics::builder::MetricsQueryBuilder;

pub use metrics::collector::MetricsCollector;

pub use parallel::ParallelQueryBuilder;

Modules

core

Core query engine: builder, error types, type states, and try-pipeline.

macros

Convenience macros: rinq_explain! for timing and pred! for predicate shorthand.

metrics

Metrics-instrumented query builder and collector.

parallel

Parallel query execution via rayon.

serde

Serde-oriented import path for crate::QueryBuilder.

Macros

pred

Build a predicate closure from a field-expression shorthand.

rinq_explain

Time and optionally log a query terminal operation.

Type Aliases

FilteredQuery

A query in the filtered (chainable intermediate) state.

InitialQuery

A query in the initial state, created directly from a collection.

ProjectedQuery

A query in the projected state, ready for final collection.

SortedQuery

A query in the sorted state.