Squashed commit.

Author: NervousNullPtr

.github/workflows/rust.yml

@@ -0,0 +1,22 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build
+      run: cargo build --all-features --verbose
+    - name: Run tests
+      run: cargo test --all-features --verbose

Cargo.toml

@@ -14,8 +14,12 @@ include = ["src/**/*", "README.md", "LICENSE*", "Cargo.toml"]
 features = ["debug-tools", "method-api"]
 
 [dependencies]
+quantor_fnmeta = { path = "fnmeta" }  # internal crate
 
 [features]
 default = []
 debug-tools = []
-method-api = []
+method-api = []
+
+[workspace]
+members = ["fnmeta"]

fnmeta/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "quantor_fnmeta"
+description = "Internal macro for advanced errors."
+version = "1.0.0"
+edition = "2021"
+publish = false
+
+[lib]
+proc-macro = true

fnmeta/src/lib.rs

@@ -0,0 +1,80 @@
+#![doc(hidden)]
+//! Internal procedural macros for `quantor`.
+//!
+//! Provides `#[function_name]`, which injects a local `const FUNCTION_NAME: &str`
+//! into any function or method, containing the function’s name as a string.
+//!
+//! Not intended for public use; this crate is private and excluded from docs.
+//!
+//! ## Example
+//! ```ignore
+//! #[function_name]
+//! fn run() {
+//!     println!("{}", FUNCTION_NAME);
+//! }
+//! ```
+
+use proc_macro::{TokenStream, TokenTree, Group, Delimiter};
+
+#[doc(hidden)]
+/// Injects a local `FUNCTION_NAME: &str` constant with the name of the current function.
+///
+/// Works on both free functions and `impl` methods. Zero runtime cost.  
+/// Intended for internal diagnostics, logging, and tracing.
+///
+/// ## Example
+/// ```ignore
+/// #[function_name]
+/// fn compute() {
+///     println!("This is '{}'", FUNCTION_NAME);
+/// }
+/// ```
+///
+/// This macro is internal to the `quantor` crate and not publicly exported.
+#[proc_macro_attribute]
+pub fn function_name(_attr: TokenStream, input: TokenStream) -> TokenStream {
+    let mut tokens = input.into_iter();
+    let mut output = Vec::new();
+
+    while let Some(token) = tokens.next() {
+        match &token {
+            TokenTree::Ident(ident) if ident.to_string() == "fn" => {
+                output.push(token.clone()); // push 'fn'
+
+                if let Some(TokenTree::Ident(name)) = tokens.next() {
+                    let fn_name_str = name.to_string();
+                    output.push(TokenTree::Ident(name)); // push function name
+
+                    // Copy everything until `{`
+                    while let Some(next_token) = tokens.next() {
+                        match &next_token {
+                            TokenTree::Group(group) if group.delimiter() == Delimiter::Brace => {
+                                let original_body = group.stream();
+                                let injected = format!(
+                                    "const FUNCTION_NAME: &str = \"{}\"; {}",
+                                    fn_name_str,
+                                    original_body
+                                );
+                                let new_body = injected.parse::<TokenStream>().unwrap();
+                                let new_group = Group::new(Delimiter::Brace, new_body);
+                                output.push(TokenTree::Group(new_group));
+                                break;
+                            }
+                            TokenTree::Group(group) => {
+                                output.push(TokenTree::Group(Group::new(
+                                    group.delimiter(),
+                                    group.stream(),
+                                )));
+                            }
+                            _ => output.push(next_token),
+                        }
+                    }
+                    continue;
+                }
+            }
+            _ => output.push(token),
+        }
+    }
+
+    TokenStream::from_iter(output)
+}

readme.md

@@ -1,55 +1,73 @@
 # quantor
 [![Crates.io](https://img.shields.io/crates/v/quantor.svg)](https://crates.io/crates/quantor)
 [![Docs.rs](https://docs.rs/quantor/badge.svg)](https://docs.rs/quantor)
-[![License](https://img.shields.io/crates/l/quantor)](https://crates.io/crates/quantor)
 [![Downloads](https://img.shields.io/crates/d/quantor.svg)](https://crates.io/crates/quantor)
-[![MSRV](https://img.shields.io/badge/MSRV-1.61+-blue)](https://github.com/nervousnullptr/quantor#msrv)
+[![MSRV](https://img.shields.io/badge/MSRV-1.58.1+-blue)](https://github.com/nervousnullptr/quantor#msrv)
 
-**Declarative quantifiers and logical assertions for Rust iterators and collections.**  
-`quantor` provides lightweight, expressive tools for validation, filtering, and testing — with zero dependencies.
+**Declarative logic for iterators and collections.**  
+`quantor` lets you express conditions like `forall`, `exists`, `none`, and `existsforall` directly over data — making filtering, validation, and testing expressive, readable, and idiomatic.
 
----
+## Why Quantor?
 
-## ✨ Features
-`quantor` lets you express logic over data in a way that feels natural and readable:
+Rust's iterator methods are powerful, but when you want to write logic that reads like:
 
-- 📐 **Quantifiers** — Use familiar constructs like `forall`, `exists`, `none`, and `exactly_one`.
-- 🧹 **Selection utilities** — Filter with `select_where`, extract duplicates, check for uniqueness.
-- 🧠 **Structured logic** — Run `pairwise` comparisons or validate equality across items.
-- 🧪 **Assertions** — Add runtime guarantees with `assert_forall!`, `assert_exists!`, etc.
+- "All elements are even"
+- "At least one user is active"
+- "Exactly three items matched a condition"
 
----
+you're often stuck with `.all()`, `.any()`, `.filter().count()`, and some `assert!` noise.
 
-## 🚀 Example
+With `quantor`, your code becomes declarative and reflects the logic you care about, not the mechanics.
+
+## Highlights
+
+- **Quantifiers** — `forall`, `exists`, `none`, `exactly_one`, `exactly_n`, `all_equal`, `pairwise`, `forallexists`, and more.
+- **Assertions** — Runtime logic assertions like `assert_forall!`, `assert_unique!`, `assert_pairwise!`, with expressive failure output.
+- **Predicate-based selection** — Filter, deduplicate, or extract based on logic: `select_where`, `select_unique`, `select_duplicates`.
+- **Diagnostics** — Inspect failing indices, collect mismatches, or integrate with fuzzing tools using `QuantorError`.
+- **Rust-native, ergonomic API** – Works with any `IntoIterator`, zero dependencies, and optional `.method()` trait extension.
+
+## Example
+
+If you're validating input for a product catalog:
 
 ```rust
-use quantor::{forall, select_where, assert_forall};
+use quantor::{forall, exists, pairwise, assert_unique};
 
-let nums = vec![2, 4, 6];
+#[derive(Debug)]
+struct Product {
+    id:     u32,
+    price:  f64,
+    active: bool,
+}
 
-// Check if all elements are even
-assert!(forall(&nums, |x| x % 2 == 0));
+let products = vec![
+    Product { id: 1, price: 19.99, active: true },
+    Product { id: 2, price: 29.99, active: true },
+    Product { id: 3, price: 0.0,   active: false },
+];
 
-// Use the macro version for test-friendly assertions
-assert_forall!(&nums, |x| x % 2 == 0);
+// Check that all active products have a price > 0.
+forall(&products, |p| !p.active || p.price > 0.0)?;
 
-// Extract matching elements
-let evens = select_where(&nums, |x| x % 2 == 0);
-assert_eq!(evens, vec![&2, &4, &6]);
+// Ensure IDs are unique.
+assert_unique!(&products.iter().map(|p| p.id).collect::<Vec<_>>());
+
+// Confirm at least one product is available.
+exists(&products, |p| p.active)?;
 ```
----
 
-## 📦 Installation
-Add this to your `Cargo.toml`:
+This is readable, declarative, and robust – and every check returns a Result with index-level error diagnostics.
+
+## Installation
+Add `quantor` to your `Cargo.toml`:
 ```
 quantor = "0.1"
 ```
 Optional features:
-* `method-api` – Enable `.forall()` and other iterator-style methods.
-* `debug-tools` – Add debugging macros like `debug_assert_forall!` or `debug_exists!`.
-
----
+* `method-api` — Enables `.forall()`, `.exists()`, `.select_where()`, etc. on slices and iterators.
+* `debug-tools` — Enables `debug_assert_*` and `debug_*` macros for non-panicking diagnostics.
 
 ## 📚 Documentation
 
-See docs.rs/quantor for full API documentation and examples.
+See [docs.rs](https://docs.rs/quantor) for full API documentation and examples.