devnagari 0.1.0

/// Extension trait that adds Devanagari method names to common types.
/// Import via `use devnagari::prelude::*`.

// ── Slice / Vec / String helpers ──────────────────────────────────────────────

pub trait देवनागरीसूचीविस्तार<T> {
    /// `len()` — length of the collection
    fn लम्बाई(&self) -> usize;
    /// `is_empty()` — is the collection empty?
    fn रिक्त_है(&self) -> bool;
    /// `first()` — first element
    fn प्रथम(&self) -> Option<&T>;
    /// `last()` — last element
    fn अंतिम(&self) -> Option<&T>;
    /// `contains(x)` — does the collection contain `x`?
    fn समाविष्ट(&self, x: &T) -> bool where T: PartialEq;
}

impl<T> देवनागरीसूचीविस्तार<T> for Vec<T> {
    fn लम्बाई(&self) -> usize { self.len() }
    fn रिक्त_है(&self) -> bool { self.is_empty() }
    fn प्रथम(&self) -> Option<&T> { self.first() }
    fn अंतिम(&self) -> Option<&T> { self.last() }
    fn समाविष्ट(&self, x: &T) -> bool where T: PartialEq { self.contains(x) }
}

impl<T> देवनागरीसूचीविस्तार<T> for [T] {
    fn लम्बाई(&self) -> usize { self.len() }
    fn रिक्त_है(&self) -> bool { self.is_empty() }
    fn प्रथम(&self) -> Option<&T> { self.first() }
    fn अंतिम(&self) -> Option<&T> { self.last() }
    fn समाविष्ट(&self, x: &T) -> bool where T: PartialEq { self.contains(x) }
}

// ── String helpers ────────────────────────────────────────────────────────────

pub trait देवनागरीपाठविस्तार {
    /// `len()` — byte length
    fn लम्बाई(&self) -> usize;
    /// `is_empty()` — is the string empty?
    fn रिक्त_है(&self) -> bool;
    /// `to_uppercase()` — convert to uppercase
    fn बड़ेअक्षर(&self) -> String;
    /// `to_lowercase()` — convert to lowercase
    fn छोटेअक्षर(&self) -> String;
    /// `trim()` — trim whitespace
    fn छाँटो(&self) -> &str;
    /// `contains(pat)` — does the string contain the pattern?
    fn समाविष्ट(&self, pat: &str) -> bool;
    /// `starts_with(pat)`
    fn से_शुरू(&self, pat: &str) -> bool;
    /// `ends_with(pat)`
    fn पर_समाप्त(&self, pat: &str) -> bool;
    /// `replace(from, to)`
    fn बदलो(&self, from: &str, to: &str) -> String;
    /// `split(pat)` — split into parts
    fn विभाजित<'a>(&'a self, pat: &str) -> Vec<&'a str>;
    /// `chars().count()` — number of Unicode scalar values (not bytes)
    fn अक्षर_संख्या(&self) -> usize;
}

impl देवनागरीपाठविस्तार for str {
    fn लम्बाई(&self) -> usize { self.len() }
    fn रिक्त_है(&self) -> bool { self.is_empty() }
    fn बड़ेअक्षर(&self) -> String { self.to_uppercase() }
    fn छोटेअक्षर(&self) -> String { self.to_lowercase() }
    fn छाँटो(&self) -> &str { self.trim() }
    fn समाविष्ट(&self, pat: &str) -> bool { self.contains(pat) }
    fn से_शुरू(&self, pat: &str) -> bool { self.starts_with(pat) }
    fn पर_समाप्त(&self, pat: &str) -> bool { self.ends_with(pat) }
    fn बदलो(&self, from: &str, to: &str) -> String { self.replace(from, to) }
    fn विभाजित<'a>(&'a self, pat: &str) -> Vec<&'a str> { self.split(pat).collect() }
    fn अक्षर_संख्या(&self) -> usize { self.chars().count() }
}

impl देवनागरीपाठविस्तार for String {
    fn लम्बाई(&self) -> usize { self.len() }
    fn रिक्त_है(&self) -> bool { self.is_empty() }
    fn बड़ेअक्षर(&self) -> String { self.to_uppercase() }
    fn छोटेअक्षर(&self) -> String { self.to_lowercase() }
    fn छाँटो(&self) -> &str { self.trim() }
    fn समाविष्ट(&self, pat: &str) -> bool { self.contains(pat) }
    fn से_शुरू(&self, pat: &str) -> bool { self.starts_with(pat) }
    fn पर_समाप्त(&self, pat: &str) -> bool { self.ends_with(pat) }
    fn बदलो(&self, from: &str, to: &str) -> String { self.replace(from, to) }
    fn विभाजित<'a>(&'a self, pat: &str) -> Vec<&'a str> { self.split(pat).collect() }
    fn अक्षर_संख्या(&self) -> usize { self.chars().count() }
}

// ── Iterator extensions ───────────────────────────────────────────────────────

pub trait देवनागरीइटरेटरविस्तार: Iterator + Sized {
    /// `count()` — total number of elements
    fn गणना(self) -> usize { self.count() }

    /// `collect::<Vec<_>>()` — collect into a Vec
    fn संग्रह<B: FromIterator<Self::Item>>(self) -> B { self.collect() }

    /// `sum()` — sum of all elements
    fn योग<S>(self) -> S where S: std::iter::Sum<Self::Item> { self.sum() }

    /// `product()` — product of all elements
    fn गुणनफल<P>(self) -> P where P: std::iter::Product<Self::Item> { self.product() }

    /// `max()` — maximum element
    fn अधिकतम(self) -> Option<Self::Item> where Self::Item: Ord { self.max() }

    /// `min()` — minimum element
    fn न्यूनतम(self) -> Option<Self::Item> where Self::Item: Ord { self.min() }

    /// `any(f)` — is there any element matching the predicate?
    fn कोई<F: FnMut(Self::Item) -> bool>(mut self, f: F) -> bool { self.any(f) }

    /// `all(f)` — do all elements match the predicate?
    fn सभी<F: FnMut(Self::Item) -> bool>(mut self, f: F) -> bool { self.all(f) }

    /// `filter(f)` — keep elements matching the predicate
    fn छानो<F>(self, f: F) -> std::iter::Filter<Self, F>
    where F: FnMut(&Self::Item) -> bool { self.filter(f) }

    /// `map(f)` — transform each element
    fn रूपांतर<B, F>(self, f: F) -> std::iter::Map<Self, F>
    where F: FnMut(Self::Item) -> B { self.map(f) }

    /// `flat_map(f)` — transform and flatten
    fn समतलरूपांतर<U, F>(self, f: F) -> std::iter::FlatMap<Self, U, F>
    where F: FnMut(Self::Item) -> U, U: IntoIterator { self.flat_map(f) }

    /// `take(n)` — take first `n` elements
    fn लो(self, n: usize) -> std::iter::Take<Self> { self.take(n) }

    /// `skip(n)` — skip first `n` elements
    fn छोड़ो(self, n: usize) -> std::iter::Skip<Self> { self.skip(n) }

    /// `enumerate()` — pair each element with its index
    fn क्रमांकित(self) -> std::iter::Enumerate<Self> { self.enumerate() }

    /// `peekable()` — make the iterator peekable
    fn झाँकने_योग्य(self) -> std::iter::Peekable<Self> { self.peekable() }

    /// `zip(other)` — zip two iterators together
    fn जोड़ो<U: IntoIterator>(self, other: U) -> std::iter::Zip<Self, U::IntoIter> { self.zip(other) }

    /// `chain(other)` — chain two iterators
    fn जोड़_दो<U>(self, other: U) -> std::iter::Chain<Self, U::IntoIter>
    where U: IntoIterator<Item = Self::Item> { self.chain(other) }

    /// `find(f)` — find first matching element
    fn खोजो<F: FnMut(&Self::Item) -> bool>(mut self, f: F) -> Option<Self::Item> { self.find(f) }

    /// `position(f)` — index of first matching element
    fn स्थान<F: FnMut(Self::Item) -> bool>(mut self, f: F) -> Option<usize> { self.position(f) }

    /// `fold(init, f)` — reduce with accumulator
    fn संकुचन<B, F: FnMut(B, Self::Item) -> B>(self, init: B, f: F) -> B { self.fold(init, f) }

    /// `for_each(f)` — run a closure on each element
    fn प्रत्येक_हेतु<F: FnMut(Self::Item)>(self, f: F) { self.for_each(f) }

    /// `rev()` — reverse the iterator
    fn उलटो(self) -> std::iter::Rev<Self> where Self: DoubleEndedIterator { self.rev() }
}

impl<I: Iterator + Sized> देवनागरीइटरेटरविस्तार for I {}

// ── Option helpers ────────────────────────────────────────────────────────────

pub trait देवनागरीविकल्पविस्तार<T> {
    /// `is_some()` — does a value exist?
    fn कुछ_है(&self) -> bool;
    /// `is_none()` — is it empty?
    fn रिक्त_है(&self) -> bool;
    /// `unwrap()` — extract value or panic
    fn खोलो(self) -> T;
    /// `unwrap_or(default)` — extract or use default
    fn या(self, default: T) -> T;
    /// `map(f)` — transform the inner value
    fn रूपांतर<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U>;
}

impl<T> देवनागरीविकल्पविस्तार<T> for Option<T> {
    fn कुछ_है(&self) -> bool { self.is_some() }
    fn रिक्त_है(&self) -> bool { self.is_none() }
    fn खोलो(self) -> T { self.unwrap() }
    fn या(self, default: T) -> T { self.unwrap_or(default) }
    fn रूपांतर<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> { self.map(f) }
}

// ── Result helpers ────────────────────────────────────────────────────────────

pub trait देवनागरीफलविस्तार<T, E> {
    /// `is_ok()` — is the result successful?
    fn ठीक_है(&self) -> bool;
    /// `is_err()` — is the result an error?
    fn त्रुटि_है(&self) -> bool;
    /// `unwrap()` — extract value or panic
    fn खोलो(self) -> T where E: std::fmt::Debug;
    /// `unwrap_or(default)` — extract or use default
    fn या(self, default: T) -> T;
    /// `map(f)` — transform the Ok value
    fn रूपांतर<U, F: FnOnce(T) -> U>(self, f: F) -> Result<U, E>;
}

impl<T, E> देवनागरीफलविस्तार<T, E> for Result<T, E> {
    fn ठीक_है(&self) -> bool { self.is_ok() }
    fn त्रुटि_है(&self) -> bool { self.is_err() }
    fn खोलो(self) -> T where E: std::fmt::Debug { self.unwrap() }
    fn या(self, default: T) -> T { self.unwrap_or(default) }
    fn रूपांतर<U, F: FnOnce(T) -> U>(self, f: F) -> Result<U, E> { self.map(f) }
}