# devnagari
[](https://crates.io/crates/devnagari)
[](https://docs.rs/devnagari)
[](LICENSE)
**Write Rust in Devanagari — Hindi and Sanskrit both supported.**
Devanagari Unicode characters have been valid Rust identifiers since Rust 1.53. This crate builds on that foundation to give you:
- **`देव! { }`** — a proc-macro that translates Devanagari *keywords* (`कार्य`, `यदि`, `मिलान`…) into Rust keywords so the compiler accepts them
- **Type aliases** — `पूर्णांक` for `i32`, `पाठ` for `String`, `सूची<T>` for `Vec<T>`, and 25+ more
- **Macro aliases** — `छापो!` for `println!`, `स्वरूप!` for `format!`, and more
- **Extension traits** — `.लम्बाई()`, `.रिक्त_है()`, `.योग()`, `.छानो()` and 30+ methods on standard types
- **Sanskrit vocabulary** — classical Paninian/Vedic alternatives: `वर्ण` (`char`), `सूत्र` (`String`), `अङ्क` (`i32`), number constants `एक`–`कोटि`, and Sanskrit keyword synonyms
---
## Installation
```toml
[dependencies]
devnagari = "0.1"
```
Then import the prelude:
```rust
use devnagari::prelude::*;
```
---
## How `देव! { }` works
Rust does not accept Devanagari as *keywords* (`fn`, `let`, `if`, etc.) but it does accept them as *identifiers*. `देव! { }` is a proc-macro that walks the token stream of its input and substitutes Devanagari keyword identifiers with their Rust equivalents before the compiler sees them.
```
कार्य → fn मान → let यदि → if मिलान → match
```
Everything that is **not** a keyword — your function names, variable names, struct fields, type names — passes through completely unchanged. So `अर्जुन`, `क्षेत्रफल`, `विद्यार्थी` remain exactly as you wrote them.
```rust
use devnagari::prelude::*;
देव! {
कार्य जोड़(क: पूर्णांक, ख: पूर्णांक) -> पूर्णांक {
क + ख // क, ख are your identifiers — untouched
} // पूर्णांक is a type alias — also untouched
}
// expands to: fn जोड़(क: i32, ख: i32) -> i32 { क + ख }
```
### Block form vs attribute form
**Block form** — wrap multiple items:
```rust
देव! {
संरचना बिंदु { x: दशमलव, y: दशमलव }
क्रियान्वयन बिंदु {
कार्य नया(x: दशमलव, y: दशमलव) -> स्वप्रकार {
स्वप्रकार { x, y }
}
}
}
```
**Attribute form** — apply to a single item:
```rust
#[देव_attr]
संरचना बिंदु { x: दशमलव, y: दशमलव }
#[देव_attr]
क्रियान्वयन बिंदु {
कार्य दूरी(&स्व, अन्य: &स्वप्रकार) -> दशमलव {
मान dx = स्व.x - अन्य.x;
मान dy = स्व.y - अन्य.y;
(dx * dx + dy * dy).sqrt()
}
}
```
**ASCII aliases** — for editors that struggle with Devanagari macro names:
```rust
dev! { ... } // same as देव! { }
#[dev_attr] // same as #[देव_attr]
```
---
## Hindi keywords
These are the primary keyword mappings using everyday Hindi vocabulary.
| `कार्य` | `fn` | function / work |
| `मान` | `let` | value / binding |
| `परिवर्तनीय` | `mut` | mutable |
| `यदि` | `if` | if |
| `अन्यथा` | `else` | otherwise |
| `जबतक` | `while` | as long as |
| `प्रत्येक` | `for` | for each |
| `चक्र` | `loop` | cycle / loop |
| `मिलान` | `match` | match / compare |
| `वापस` | `return` | back / return |
| `रुको` | `break` | stop |
| `जारी` | `continue` | continue |
| `में` | `in` | in |
| `संरचना` | `struct` | structure |
| `गणना` | `enum` | enumeration |
| `विशेषता` | `trait` | characteristic |
| `क्रियान्वयन` | `impl` | implementation |
| `जहाँ` | `where` | where |
| `सार्वजनिक` | `pub` | public |
| `खंड` | `mod` | module / section |
| `उपयोग` | `use` | use |
| `प्रकार` | `type` | type |
| `स्थिरांक` | `const` | constant |
| `स्थायी` | `static` | static |
| `स्व` | `self` | self |
| `स्वप्रकार` | `Self` | Self (type) |
| `पितृ` | `super` | parent / super |
| `मूल` | `crate` | crate |
| `जैसे` | `as` | as (cast / alias) |
| `अतुल्य` | `async` | asynchronous |
| `प्रतीक्षा` | `await` | wait / await |
| `चल` | `move` | move closure |
| `गतिशील` | `dyn` | dynamic dispatch |
| `असुरक्षित` | `unsafe` | unsafe |
| `बाह्य` | `extern` | external |
| `सत्य` | `true` | true |
| `असत्य` | `false` | false |
| `संदर्भ_बंध` | `ref` | reference binding |
---
## Sanskrit keywords
Classical Sanskrit alternatives that can be used instead of or alongside the Hindi keywords above. Both sets work inside the same `देव! { }` block — mix freely.
| `कर्म` | `fn` | action / deed (Bhagavad Gita) |
| `नियत` | `let` | fixed / assigned |
| `विकारी` | `mut` | subject to modification |
| `चेत्` | `if` | if (classical conditional) |
| `यावत्` | `while` | as long as (classical) |
| `आवर्तन` | `loop` | repetition / cycling |
| `विराम` | `break` | pause / stop |
| `अनुवर्तन` | `continue` | following / proceeding |
| `निवृत्ति` | `return` | returning / cessation |
| `कृते` | `for` | for the purpose of (`impl T for U`)|
| `रचना` | `struct` | creation / structure |
| `लक्षण` | `trait` | characteristic (Paninian grammar) |
| `साधन` | `impl` | means / implementation |
| `ध्रुव` | `const` | fixed / pole star |
| `शाश्वत` | `static` | eternal / unchanging |
| `यत्र` | `where` | where (classical locative) |
| `आत्म` | `self` | self (Vedantic concept) |
| `आत्मप्रकार` | `Self` | Self type |
| `इव` / `यथा` | `as` | like / as (Sanskrit comparative) |
| `असमकालिक` | `async` | asynchronous |
| `प्रतीक्षण` | `await` | act of waiting |
| `गमन` | `move` | movement |
| `अरक्षित` | `unsafe` | unprotected |
| `बाह्यिक` | `extern` | external |
| `अंश` | `mod` | part / portion |
---
## Type aliases
Import via `use devnagari::prelude::*`.
### Hindi type aliases
| `पूर्णांक` | `i32` | integer (default) |
| `दीर्घपूर्णांक` | `i64` | long integer |
| `महापूर्णांक` | `i128` | 128-bit integer |
| `लघुपूर्णांक` | `i8` | small integer |
| `मध्यपूर्णांक` | `i16` | medium integer |
| `सूचकांक` | `isize` | pointer-sized integer |
| `अष्टांक` | `u8` | unsigned 8-bit |
| `बाइट` | `u8` | byte (I/O alias) |
| `षोडशांक` | `u16` | unsigned 16-bit |
| `अचिह्नित` | `u32` | unsigned 32-bit |
| `दीर्घाचिह्नित` | `u64` | unsigned 64-bit |
| `आकार` | `usize` | size / index type |
| `दशमलव` | `f64` | decimal (default float) |
| `लघुदशमलव` | `f32` | single-precision float |
| `पाठ` | `String` | text (owned) |
| `अक्षर` | `char` | character |
| `बूलियन` | `bool` | boolean |
| `शून्य` | `()` | unit / void |
| `सूची<T>` | `Vec<T>` | list / vector |
| `कोश<K, V>` | `HashMap<K, V>` | dictionary |
| `क्रमकोश<K, V>` | `BTreeMap<K, V>` | ordered dictionary |
| `समुच्चय<T>` | `HashSet<T>` | set |
| `द्विसिरासूची<T>` | `VecDeque<T>` | double-ended queue |
| `विकल्प<T>` | `Option<T>` | optional value |
| `फल<T, E>` | `Result<T, E>` | result / outcome |
| `पिटारा<T>` | `Box<T>` | heap box |
| `साझा<T>` | `Arc<T>` | shared (thread-safe) |
| `आरसी<T>` | `Rc<T>` | reference-counted |
| `कोशिका<T>` | `Cell<T>` | interior mutable cell |
| `परिवर्तकोशिका<T>` | `RefCell<T>` | runtime borrow cell |
| `ताला<T>` | `Mutex<T>` | mutex lock |
| `पाठताला<T>` | `RwLock<T>` | read-write lock |
### Sanskrit type aliases
| `अङ्क` | `i32` | digit/numeral (Paninian) |
| `महाङ्क` | `i64` | great number |
| `राशि` | `f64` | quantity (Sanskrit math term) |
| `लघुराशि` | `f32` | small quantity |
| `वर्ण` | `char` | phoneme/letter (Paninian) |
| `सूत्र` | `String` | thread / formula / aphorism |
| `सत्यासत्य` | `bool` | true-or-false (dvandva) |
| `परिमाण` | `usize` | measure / quantity |
| `श्रेणी<T>` | `Vec<T>` | series / row / sequence |
| `सम्भव<T>` | `Option<T>` | possible / potential |
| `परिणाम<T, E>` | `Result<T, E>` | outcome / result |
| `निघण्टु<K, V>` | `HashMap<K, V>` | glossary / lexicon (Vedic) |
| `अनुक्रम<K, V>` | `BTreeMap<K, V>` | ordered sequence |
| `वर्गः<T>` | `HashSet<T>` | class / group / set |
| `पिटक<T>` | `Box<T>` | basket / container |
| `संयोग<T>` | `Arc<T>` | union / conjunction |
---
## Constants & variants
### Boolean, ordering, math
| `सत्य` | `true` | true |
| `असत्य` | `false` | false |
| `कुछ(v)` | `Some(v)` | a value is present |
| `रिक्त` | `None` | no value |
| `ठीक(v)` | `Ok(v)` | success |
| `त्रुटि(e)` | `Err(e)` | error |
| `कम` | `Ordering::Less` | less than |
| `बराबर` | `Ordering::Equal` | equal |
| `अधिक` | `Ordering::Greater` | greater than |
| `पाई` | `3.14159…` (π) | pi |
| `प्रकृति` | `2.71828…` (e) | Euler's number |
| `द्विमूल` | `1.41421…` (√2) | square root of 2 |
| `अनंत` | `f64::INFINITY` | infinity |
| `अपरिभाषित` | `f64::NAN` | not a number |
### Sanskrit variant aliases
| `विद्यमान(v)` | `Some(v)` | existing / present |
| `अविद्यमान` | `None` | non-existing / absent |
| `सिद्ध(v)` | `Ok(v)` | accomplished / proven |
| `दोष(e)` | `Err(e)` | fault / defect |
### Sanskrit number constants (`i32`)
| `नल` | `0` | `एकादश` | `11` |
| `एक` | `1` | `द्वादश` | `12` |
| `द्वि` | `2` | `विंशति` | `20` |
| `त्रि` | `3` | `पञ्चाशत्` | `50` |
| `चतुर` | `4` | `शत` | `100` |
| `पञ्च` | `5` | `सहस्र` | `1,000` |
| `षट` | `6` | `लक्ष` | `1,00,000` |
| `सप्त` | `7` | `कोटि` | `1,00,00,000` |
| `अष्ट` | `8` | | |
| `नव` | `9` | | |
| `दश` | `10` | | |
`usize` variants: `नल_आ`, `एक_आ`, `द्वि_आ`, `त्रि_आ`, `दश_आ`, `शत_आ`, `सहस्र_आ`
---
## Macros
### Hindi macros
| `छापो!` | `println!` | Print line to stdout |
| `छाप!` | `print!` | Print without newline |
| `त्रुटि_छापो!` | `eprintln!` | Print line to stderr |
| `स्वरूप!` | `format!` | Format into a `String` |
| `लिखो!` | `write!` | Write formatted text to a writer |
| `पंक्तिलिखो!` | `writeln!` | Write line to a writer |
| `जाँचो!` | `dbg!` | Debug-print with file and line |
| `सूची_बनाओ!` | `vec!` | Create a `Vec` |
| `घबराओ!` | `panic!` | Panic with a message |
| `दावा!` | `assert!` | Assert a condition |
| `समता_दावा!` | `assert_eq!` | Assert equality |
| `असमता_दावा!` | `assert_ne!` | Assert inequality |
| `करनाहै!` | `todo!` | Mark as not yet implemented |
| `अपूर्ण!` | `unimplemented!` | Mark as unimplemented |
| `अगम्य!` | `unreachable!` | Mark as unreachable |
| `संयोग!` | `concat!` | Concatenate literals |
| `पाठसंलग्न!` | `include_str!` | Include file as `&str` |
| `बाइट_संलग्न!` | `include_bytes!` | Include file as `&[u8]` |
| `पर्यावरण!` | `env!` | Read env var at compile time |
| `विन्यास!` | `cfg!` | Evaluate cfg condition |
| `नाम_पाठ!` | `stringify!` | Stringify tokens |
### Sanskrit macros
| `वद!` | `println!` | speak / say |
| `उच्चार!` | `print!` | pronounce / utter |
| `दोषवद!` | `eprintln!` | speak error |
| `रचय!` | `format!` | compose / create |
| `श्रेणी_रचय!` | `vec!` | create a series |
| `भय!` | `panic!` | fear / alarm |
| `निश्चय!` | `assert!` | certainty / determination |
| `समत्व_निश्चय!` | `assert_eq!` | equality certainty |
| `विषमत्व_निश्चय!` | `assert_ne!` | inequality certainty |
| `परीक्षण!` | `dbg!` | examination / testing |
| `कर्तव्य!` | `todo!` | duty / what must be done |
| `असाधित!` | `unimplemented!` | not yet accomplished |
| `अगम्य_पथ!` | `unreachable!` | unreachable path |
---
## Extension traits
All activated by `use devnagari::prelude::*`.
### `Vec<T>` and `[T]`
| `.लम्बाई()` | `.len()` | number of elements |
| `.रिक्त_है()` | `.is_empty()` | true if empty |
| `.प्रथम()` | `.first()` | first element (`Option<&T>`) |
| `.अंतिम()` | `.last()` | last element (`Option<&T>`) |
| `.समाविष्ट(x)` | `.contains(x)` | true if `x` is present |
### `String` and `str`
| `.लम्बाई()` | `.len()` | byte length |
| `.रिक्त_है()` | `.is_empty()` | true if empty |
| `.अक्षर_संख्या()` | `.chars().count()` | number of Unicode characters|
| `.बड़ेअक्षर()` | `.to_uppercase()` | convert to uppercase |
| `.छोटेअक्षर()` | `.to_lowercase()` | convert to lowercase |
| `.छाँटो()` | `.trim()` | trim whitespace |
| `.समाविष्ट(pat)` | `.contains(pat)` | substring check |
| `.से_शुरू(pat)` | `.starts_with(pat)` | prefix check |
| `.पर_समाप्त(pat)` | `.ends_with(pat)` | suffix check |
| `.बदलो(from, to)` | `.replace(from, to)` | replace substring |
| `.विभाजित(pat)` | `.split(pat).collect()` | split into `Vec<&str>` |
### `Iterator`
| `.गणना()` | `.count()` | count elements |
| `.संग्रह()` | `.collect()` | collect into a collection |
| `.योग()` | `.sum()` | sum all elements |
| `.गुणनफल()` | `.product()` | product of all elements |
| `.अधिकतम()` | `.max()` | maximum element |
| `.न्यूनतम()` | `.min()` | minimum element |
| `.कोई(f)` | `.any(f)` | true if any element matches |
| `.सभी(f)` | `.all(f)` | true if all elements match |
| `.छानो(f)` | `.filter(f)` | keep elements matching predicate |
| `.रूपांतर(f)` | `.map(f)` | transform each element |
| `.समतलरूपांतर(f)` | `.flat_map(f)` | transform and flatten |
| `.लो(n)` | `.take(n)` | take first `n` elements |
| `.छोड़ो(n)` | `.skip(n)` | skip first `n` elements |
| `.क्रमांकित()` | `.enumerate()` | pair with index |
| `.झाँकने_योग्य()` | `.peekable()` | make peekable |
| `.जोड़ो(other)` | `.zip(other)` | zip two iterators |
| `.जोड़_दो(other)` | `.chain(other)` | chain two iterators |
| `.खोजो(f)` | `.find(f)` | first matching element |
| `.स्थान(f)` | `.position(f)` | index of first match |
| `.संकुचन(init, f)` | `.fold(init, f)` | reduce with accumulator |
| `.प्रत्येक_हेतु(f)` | `.for_each(f)` | run closure on each element |
| `.उलटो()` | `.rev()` | reverse (requires `DoubleEndedIterator`) |
### `Option<T>`
| `.कुछ_है()` | `.is_some()` | true if a value is present |
| `.रिक्त_है()` | `.is_none()` | true if empty |
| `.खोलो()` | `.unwrap()` | extract value or panic |
| `.या(default)` | `.unwrap_or(d)` | extract or return default |
| `.रूपांतर(f)` | `.map(f)` | transform the inner value |
### `Result<T, E>`
| `.ठीक_है()` | `.is_ok()` | true if success |
| `.त्रुटि_है()` | `.is_err()` | true if error |
| `.खोलो()` | `.unwrap()` | extract value or panic |
| `.या(default)` | `.unwrap_or(d)` | extract or return default |
| `.रूपांतर(f)` | `.map(f)` | transform the `Ok` value |
---
## Examples
### Hindi — struct, impl, match
```rust
use devnagari::prelude::*;
देव! {
संरचना विद्यार्थी {
नाम: पाठ,
अंक: पूर्णांक,
}
क्रियान्वयन विद्यार्थी {
कार्य नया(नाम: पाठ, अंक: पूर्णांक) -> स्वप्रकार {
स्वप्रकार { नाम, अंक }
}
कार्य श्रेणी(&स्व) -> &str {
मिलान स्व.अंक {
90..=100 => "उत्कृष्ट",
75..=89 => "अच्छा",
50..=74 => "सामान्य",
_ => "अनुत्तीर्ण",
}
}
}
}
fn main() {
मान छात्र = विद्यार्थी::नया("अर्जुन".to_string(), 88);
छापो!("{} की श्रेणी: {}", छात्र.नाम, छात्र.श्रेणी());
// अर्जुन की श्रेणी: अच्छा
}
```
### Hindi — enum, for loop, iterator extensions
```rust
use devnagari::prelude::*;
देव! {
गणना दिन {
सोमवार, मंगलवार, बुधवार, गुरुवार, शुक्रवार, शनिवार, रविवार,
}
कार्य सप्ताहांत_है(द: &दिन) -> bool {
मिलान द {
दिन::शनिवार | दिन::रविवार => सत्य,
_ => असत्य,
}
}
}
fn main() {
मान संख्याएँ = सूची_बनाओ![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
मान सम: सूची<पूर्णांक> = संख्याएँ.iter()
.copied()
.छानो(|&x| x % 2 == 0)
.संग्रह();
छापो!("सम संख्याएँ: {:?}", सम);
// सम संख्याएँ: [2, 4, 6, 8, 10]
मान योग: पूर्णांक = सम.iter().copied().योग();
छापो!("योगफल: {}", योग);
// योगफल: 30
}
```
### Sanskrit — struct, trait, impl
```rust
use devnagari::prelude::*;
देव! {
लक्षण क्षेत्रफल {
कर्म क्षेत्रफल(&आत्म) -> राशि;
}
रचना वृत्त { त्रिज्या: राशि }
रचना आयत { लम्बाई: राशि, चौड़ाई: राशि }
साधन क्षेत्रफल कृते वृत्त {
कर्म क्षेत्रफल(&आत्म) -> राशि {
पाई * आत्म.त्रिज्या * आत्म.त्रिज्या
}
}
साधन क्षेत्रफल कृते आयत {
कर्म क्षेत्रफल(&आत्म) -> राशि {
आत्म.लम्बाई * आत्म.चौड़ाई
}
}
}
fn main() {
नियत व = वृत्त { त्रिज्या: पञ्च as f64 };
नियत आ = आयत { लम्बाई: दश as f64, चौड़ाई: चतुर as f64 };
वद!("वृत्त का क्षेत्रफल = {:.2}", व.क्षेत्रफल());
वद!("आयत का क्षेत्रफल = {:.2}", आ.क्षेत्रफल());
}
```
### Sanskrit — number constants, Option, Result
```rust
use devnagari::prelude::*;
fn main() {
// Sanskrit numbers
नियत परिणाम: अङ्क = एक + द्वि + त्रि + चतुर + पञ्च;
वद!("१+२+३+४+५ = {}", परिणाम); // 15
// Option with Sanskrit variants
नियत मान: सम्भव<अङ्क> = विद्यमान(पञ्च * दश);
वद!("मान: {}", मान.या(नल)); // 50
// Result with Sanskrit variants
नियत फल: परिणाम<अङ्क, &str> = सिद्ध(शत);
निश्चय!(फल.ठीक_है());
// Math constants
वद!("π = {:.6}", पाई);
वद!("e = {:.6}", प्रकृति);
वद!("√2 = {:.6}", द्विमूल);
}
```
### Async (with Tokio)
```rust
use devnagari::prelude::*;
देव! {
अतुल्य कार्य डेटा_लाओ(url: &str) -> फल<पाठ, Box<गतिशील std::error::Error>> {
मान प्रतिक्रिया = reqwest::get(url).प्रतीक्षा?;
मान सामग्री = प्रतिक्रिया.text().प्रतीक्षा?;
ठीक(सामग्री)
}
}
```
---
## Module structure
```
devnagari
├── prelude — re-exports everything; use devnagari::prelude::*
├── types — Hindi type aliases (पूर्णांक, पाठ, सूची, …)
├── sanskrit — Sanskrit type aliases, number constants, variant aliases
├── constants — boolean, ordering, math constants (पाई, अनंत, …)
├── macros — Hindi + Sanskrit macro aliases
└── traits — extension traits for Vec, str, String, Iterator, Option, Result
```
The companion crate `devnagari_macros` provides the `देव!`, `dev!`, `#[देव_attr]`, and `#[dev_attr]` proc-macros. It is published separately but pulled in automatically as a dependency.
---
## Notes
- **Mixing Hindi and Sanskrit** — both keyword sets work inside the same `देव! { }` block. There is no conflict.
- **Your own names** — identifiers that are not in the keyword map (`अर्जुन`, `क्षेत्रफल`, `विद्यार्थी`, etc.) pass through untouched.
- **Regular Rust outside `देव!`** — you can mix regular Rust and Devanagari blocks freely in the same file.
- **`await`** — write `.प्रतीक्षा` (Hindi) or `.प्रतीक्षण` (Sanskrit) in place of `.await`.
- **`impl Trait for Type`** — use `कृते` (Sanskrit) or `प्रत्येक` (Hindi) for the `for` keyword in this context.
- **ASCII fallback** — if your editor or terminal cannot render Devanagari macro names, use `dev! { }` and `#[dev_attr]` instead.
---
## License
MIT — see [LICENSE](LICENSE).