tafqit 0.1.0__tar.gz

tafqit-0.1.0/CITATION.cff

@@ -0,0 +1,13 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it using the metadata from this file."
+type: software
+title: "tafqit"
+abstract: "Amounts in words (tafqit / تفقيط) in Arabic and French, with dinar/centime currency forms for invoices and cheques"
+authors:
+  - family-names: Chougui
+    given-names: Abdeldjalil
+version: 0.1.0
+license: MIT
+repository-code: "https://github.com/AbdeldjalilChougui/tafqit"
+url: "https://github.com/AbdeldjalilChougui/tafqit"
+keywords: [arabic, french, numbers, words, invoice]

tafqit-0.1.0/Cargo.lock

@@ -0,0 +1,177 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a37b2691796cffeb8a8cd305ac66e65841559f147f4e63231d0eafa4db5384d1"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.191"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
+dependencies = [
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tafqit"
+version = "0.1.0"
+
+[[package]]
+name = "tafqit-py"
+version = "0.1.0"
+dependencies = [
+ "pyo3",
+ "tafqit",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

tafqit-0.1.0/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "tafqit"
+version = "0.1.0"
+edition = "2021"
+authors = ["Abdeldjalil Chougui"]
+license = "MIT"
+description = "Amounts in words (tafqit / تفقيط) in Arabic and French, with dinar/centime currency forms for invoices and cheques"
+keywords = ["arabic", "french", "numbers", "words", "invoice"]
+categories = ["text-processing", "internationalization"]
+readme = "README.md"
+repository = "https://github.com/AbdeldjalilChougui/tafqit"
+homepage = "https://github.com/AbdeldjalilChougui/tafqit"
+include = ["src/**/*", "Cargo.toml", "Cargo.lock", "README.md", "LICENSE", "CITATION.cff"]
+
+[workspace]
+members = [".", "python"]
+
+[[bin]]
+name = "tafqit"
+path = "src/main.rs"
+
+[dependencies]

tafqit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdeldjalil Chougui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tafqit-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: tafqit
+Version: 0.1.0
+Summary: Amounts in words (tafqit) in Arabic and French, with dinar/centime forms (Rust core)
+Author: Abdeldjalil Chougui
+License: MIT
+Requires-Python: >=3.9
+Project-URL: Homepage, https://github.com/AbdeldjalilChougui/tafqit
+Project-URL: Issues, https://github.com/AbdeldjalilChougui/tafqit/issues
+Project-URL: Repository, https://github.com/AbdeldjalilChougui/tafqit

tafqit-0.1.0/README.md

@@ -0,0 +1,112 @@
+# tafqit (تفقيط)
+
+Write numbers and money amounts in words, in **Arabic** and **French**, for invoices,
+receipts and cheques. Algerian dinar/centime forms are built in. Rust library + CLI +
+Python bindings.
+
+```text
+$ tafqit 1234.50
+ألف ومائتان وأربعة وثلاثون دينارًا وخمسون سنتيمًا
+mille deux cent trente-quatre dinars et cinquante centimes
+
+$ tafqit --lang ar --cheque 2000000
+فقط مليونا دينار لا غير
+
+$ tafqit --lang fr 1000000
+un million de dinars
+```
+
+Numbers up to 999 999 999 999 (billions).
+
+## Install
+
+```sh
+cargo install tafqit --locked   # CLI
+cargo add tafqit                # Rust library
+pip install tafqit              # Python bindings (prebuilt wheels: Linux, macOS, Windows)
+```
+
+## Quick start
+
+```rust
+use tafqit::{ar, fr, Amount};
+
+let a: Amount = "1 234,50".parse()?;                 // also 1234.5, 1,234.50, 1.234,50
+a.to_arabic(&ar::DZD, &ar::Options::default())?;      // ألف ومائتان وأربعة وثلاثون دينارًا وخمسون سنتيمًا
+a.to_french(&fr::DINAR, &fr::Options::default())?;    // mille deux cent trente-quatre dinars et cinquante centimes
+
+// Bare numbers, gender and case
+ar::number(2000, &Default::default())?;                               // ألفان
+let gen = ar::Options { case: ar::Case::Genitive, ..Default::default() };
+ar::with_noun(2000, &ar::DINAR, &gen)?;                               // ألفي دينار
+ar::with_noun(13, &ar::LIRA, &Default::default())?;                   // ثلاث عشرة ليرةً (feminine noun)
+```
+
+CLI options: `--lang ar|fr|both`, `--number` (no currency), `--case nom|acc|gen`,
+`--feminine`, `--cheque` (`فقط … لا غير`), `--rectified` (French 1990 spelling),
+`--mia` (`مئة` instead of `مائة`).
+
+Python (`pip install tafqit`, or build from source):
+
+```sh
+cd python && maturin build --release -o dist && uv venv && uv pip install dist/*.whl
+```
+```python
+import tafqit
+tafqit.arabic("1234.50")             # amounts as str/int/Decimal (floats are refused)
+tafqit.arabic(2000, case="genitive") # 'ألفي دينار'
+tafqit.french(1_000_000)             # 'un million de dinars'
+tafqit.number_ar(21, feminine=True)  # 'إحدى وعشرون'
+```
+
+## Rules implemented
+
+**Arabic** (Modern Standard Arabic):
+- 1 and 2 come after the noun or use the dual form: `دينار واحد`, `ديناران`.
+- 3–10 take the opposite gender of the noun, and the noun takes the genitive plural:
+  `ثلاثة دنانير`, `ثلاث ليرات`, `ثماني ليرات`.
+- 11–99 take an accusative singular noun (tamyiz): `خمسة عشر دينارًا`. 11 and 12
+  agree with the noun (`أحد عشر` / `إحدى عشرة`). In 13–19 the unit is reversed and
+  `عشر/عشرة` agrees: `ثلاث عشرة ليرةً`.
+- Round hundreds, thousands, millions and billions are followed by a genitive
+  singular: `مائة دينار`, `ثلاثة آلاف دينار`, `مليون دينار`. Before a noun a dual
+  loses its nun (construct state): `مائتا دينار`, `ألفا دينار`, `مليونا دينار`.
+- Scale words count like nouns: `ألف`, `ألفان`, `ثلاثة آلاف`, `أحد عشر ألفًا`,
+  `مائة ألف`.
+- Case: duals, `اثنان/اثنين`, `اثنا عشر/اثني عشر` and the tens `عشرون/عشرين` change
+  between the nominative and the accusative/genitive.
+- Amounts ending in 1 or 2 after a larger part keep a noun on each part:
+  `مائة دينار ودينار واحد`, `ألف دينار وديناران`. Some invoice software writes
+  `مائة وواحد دينار` instead. The form used here is the one grammar references give.
+
+**French:**
+- Traditional spelling: `vingt et un`, `soixante et onze`, `quatre-vingts` /
+  `quatre-vingt-un`, `deux cents` / `deux cent un`.
+- `mille` is invariable and has no `un`. `cent` and `vingt` keep their plural `s`
+  before `millions`/`milliards`, because those are nouns: `deux cents millions`,
+  `quatre-vingt mille`.
+- Optional 1990 rectified spelling (`deux-cent-vingt-et-un`).
+- Currency: `un dinar`, `deux dinars`, `zéro dinar`, `un million de dinars`,
+  `… dinars et cinquante centimes`.
+
+## Tests
+
+`cargo test`. `tests/tables.rs` has about 170 known-correct spellings: Arabic dinars in
+nominative and accusative/genitive, a feminine noun, bare numbers, French traditional
+and rectified spelling, amounts, and the CLI. Every number from 0 to 20 000 is also
+spelled in both languages to catch panics. Python: `cd python && maturin build -o dist && uv venv && uv pip install
+dist/*.whl && .venv/bin/python tests/test_smoke.py`.
+
+## Status / limitations
+
+- The Arabic output has no short vowels except the tanween on the tamyiz (`دينارًا`).
+  The adjective `جزائري` is not added (`دينار جزائري` needs its own agreement rules).
+- Only dinar/centime is built in for French. In Arabic, any noun can be supplied
+  through `ar::Noun` (`ar::LIRA` shows a feminine one).
+- No ordinals (`الأول`, `premier`), no negative numbers, no decimals other than
+  hundredths.
+- Belgian/Swiss French (`septante`, `nonante`) is not supported.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

tafqit-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["maturin>=1.5,<2"]
+build-backend = "maturin"
+
+[project]
+name = "tafqit"
+version = "0.1.0"
+description = "Amounts in words (tafqit) in Arabic and French, with dinar/centime forms (Rust core)"
+license = { text = "MIT" }
+authors = [{ name = "Abdeldjalil Chougui" }]
+requires-python = ">=3.9"
+
+[project.urls]
+Homepage = "https://github.com/AbdeldjalilChougui/tafqit"
+Repository = "https://github.com/AbdeldjalilChougui/tafqit"
+Issues = "https://github.com/AbdeldjalilChougui/tafqit/issues"
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
+manifest-path = "python/Cargo.toml"

tafqit-0.1.0/python/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "tafqit-py"
+version = "0.1.0"
+edition = "2021"
+authors = ["Abdeldjalil Chougui"]
+license = "MIT"
+description = "Python bindings for tafqit"
+publish = false
+
+[lib]
+name = "tafqit"
+crate-type = ["cdylib"]
+
+[dependencies]
+tafqit = { path = "..", version = "0.1.0" }
+pyo3 = { version = "0.27", features = ["extension-module", "abi3-py39"] }

tafqit-0.1.0/python/src/lib.rs

@@ -0,0 +1,87 @@
+//! Python bindings for `tafqit`.
+
+use ::tafqit as core;
+use core::{ar, fr, Amount, Gender};
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+fn err(e: core::Error) -> PyErr {
+    PyValueError::new_err(e.to_string())
+}
+
+fn parse_amount(amount: &Bound<'_, PyAny>) -> PyResult<Amount> {
+    // Accept int, str ("1234.50"), or anything whose str() parses (e.g. Decimal).
+    if let Ok(n) = amount.extract::<u64>() {
+        return Amount::new(n, 0).map_err(err);
+    }
+    if amount.is_instance_of::<pyo3::types::PyFloat>() {
+        return Err(PyValueError::new_err("pass amounts as str, int or Decimal, not float (rounding errors)"));
+    }
+    let s: String = amount.str()?.extract()?;
+    s.parse().map_err(err)
+}
+
+fn gender(feminine: bool) -> Gender {
+    if feminine {
+        Gender::Feminine
+    } else {
+        Gender::Masculine
+    }
+}
+
+fn parse_case(case: &str) -> PyResult<ar::Case> {
+    match case {
+        "nominative" | "nom" => Ok(ar::Case::Nominative),
+        "accusative" | "acc" => Ok(ar::Case::Accusative),
+        "genitive" | "gen" => Ok(ar::Case::Genitive),
+        _ => Err(PyValueError::new_err("case must be 'nominative', 'accusative' or 'genitive'")),
+    }
+}
+
+/// Amount in Arabic words with dinar/centime forms.
+#[pyfunction]
+#[pyo3(signature = (amount, *, case="nominative", cheque=false, mia=false))]
+fn arabic(amount: &Bound<'_, PyAny>, case: &str, cheque: bool, mia: bool) -> PyResult<String> {
+    let a = parse_amount(amount)?;
+    let o = ar::Options { case: parse_case(case)?, mia_spelling: mia, ..Default::default() };
+    if cheque {
+        a.to_arabic_cheque(&ar::DZD, &o).map_err(err)
+    } else {
+        a.to_arabic(&ar::DZD, &o).map_err(err)
+    }
+}
+
+/// Amount in French words with dinar/centime forms.
+#[pyfunction]
+#[pyo3(signature = (amount, *, rectified=false))]
+fn french(amount: &Bound<'_, PyAny>, rectified: bool) -> PyResult<String> {
+    let a = parse_amount(amount)?;
+    let spelling = if rectified { fr::Spelling::Rectified1990 } else { fr::Spelling::Traditional };
+    a.to_french(&fr::DINAR, &fr::Options { spelling, ..Default::default() }).map_err(err)
+}
+
+/// A bare number in Arabic words.
+#[pyfunction]
+#[pyo3(signature = (n, *, feminine=false, case="nominative"))]
+fn number_ar(n: u64, feminine: bool, case: &str) -> PyResult<String> {
+    ar::number(n, &ar::Options { gender: gender(feminine), case: parse_case(case)?, ..Default::default() }).map_err(err)
+}
+
+/// A bare number in French words.
+#[pyfunction]
+#[pyo3(signature = (n, *, feminine=false, rectified=false))]
+fn number_fr(n: u64, feminine: bool, rectified: bool) -> PyResult<String> {
+    let spelling = if rectified { fr::Spelling::Rectified1990 } else { fr::Spelling::Traditional };
+    fr::number(n, &fr::Options { gender: gender(feminine), spelling }).map_err(err)
+}
+
+#[pymodule]
+fn tafqit(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(arabic, m)?)?;
+    m.add_function(wrap_pyfunction!(french, m)?)?;
+    m.add_function(wrap_pyfunction!(number_ar, m)?)?;
+    m.add_function(wrap_pyfunction!(number_fr, m)?)?;
+    m.add("MAX", core::MAX)?;
+    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
+    Ok(())
+}

tafqit-0.1.0/python/tests/test_smoke.py

@@ -0,0 +1,43 @@
+"""Smoke test for the tafqit Python bindings. Runs with plain `python` or pytest."""
+
+from decimal import Decimal
+
+import tafqit
+
+
+def test_amounts():
+    assert tafqit.arabic("1234.50") == "ألف ومائتان وأربعة وثلاثون دينارًا وخمسون سنتيمًا"
+    assert tafqit.arabic(2000) == "ألفا دينار"
+    assert tafqit.arabic(2000, case="genitive") == "ألفي دينار"
+    assert tafqit.arabic(Decimal("1000"), cheque=True) == "فقط ألف دينار لا غير"
+    assert tafqit.french("1234.50") == "mille deux cent trente-quatre dinars et cinquante centimes"
+    assert tafqit.french(1_000_000) == "un million de dinars"
+
+
+def test_numbers():
+    assert tafqit.number_ar(21, feminine=True) == "إحدى وعشرون"
+    assert tafqit.number_fr(80) == "quatre-vingts"
+    assert tafqit.number_fr(221, rectified=True) == "deux-cent-vingt-et-un"
+
+
+def test_errors():
+    for bad in ["abc", 12.5]:
+        try:
+            tafqit.arabic(bad)
+        except ValueError:
+            pass
+        else:
+            raise AssertionError(f"expected ValueError for {bad!r}")
+    try:
+        tafqit.number_ar(tafqit.MAX + 1)
+    except ValueError:
+        pass
+    else:
+        raise AssertionError("expected ValueError")
+
+
+if __name__ == "__main__":
+    test_amounts()
+    test_numbers()
+    test_errors()
+    print("python smoke test: OK", tafqit.__version__)

tafqit-0.1.0/src/ar.rs

@@ -0,0 +1,329 @@
+//! Arabic number words (تفقيط) with counted-noun agreement.
+//!
+//! Rules implemented (Modern Standard Arabic):
+//! - 1 and 2 follow the noun: `دينار واحد`, or use the dual alone: `ديناران`.
+//! - 3–10 take the opposite gender of the noun's singular, and the noun goes to
+//!   the genitive plural: `ثلاثة دنانير`, `ثلاث ليرات`.
+//! - 11–99: the noun is an accusative singular (tamyiz): `خمسة عشر دينارًا`;
+//!   11 and 12 agree with the noun (`أحد عشر` / `إحدى عشرة`), 13–19 have a
+//!   reversed unit and an agreeing `عشر/عشرة`.
+//! - Round hundreds, thousands, millions and billions are followed by a
+//!   genitive singular: `مائة دينار`, `ثلاثة آلاف دينار`, `مليون دينار`.
+//!   A dual before a noun loses its nun (construct state): `ألفا دينار`, `مائتا دينار`.
+//! - Case: dual and sound plural endings change between the nominative
+//!   (`اثنان`, `عشرون`, `ألفان`) and the accusative/genitive (`اثنين`, `عشرين`, `ألفين`).
+//! - The counted noun follows the last numeral. When the amount ends in 1 or 2 after a
+//!   larger part, each part keeps its own noun: `مائة دينار ودينار واحد`, `ألف دينار وديناران`.
+//!   (Some invoice tools write `مائة وواحد دينار`. The form used here is the one
+//!   grammar references recommend.)
+
+use crate::{Error, Gender, MAX};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum Case {
+    /// مرفوع: `اثنان`, `عشرون`, `ديناران`
+    #[default]
+    Nominative,
+    /// منصوب: `اثنين`, `عشرين`, `دينارين`
+    Accusative,
+    /// مجرور: same written forms as the accusative
+    Genitive,
+}
+
+impl Case {
+    fn oblique(self) -> bool {
+        self != Case::Nominative
+    }
+}
+
+/// A countable noun with the forms Arabic numerals need.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Noun {
+    /// Singular (also the genitive form after round numbers): `دينار`
+    pub singular: &'static str,
+    /// Indefinite accusative singular, used after 11–99: `دينارًا`
+    pub accusative: &'static str,
+    /// Dual, nominative: `ديناران`
+    pub dual_nom: &'static str,
+    /// Dual, accusative/genitive: `دينارين`
+    pub dual_obl: &'static str,
+    /// Plural used after 3–10: `دنانير`
+    pub plural: &'static str,
+    pub gender: Gender,
+    /// Scale words say `ألف`, not `ألف واحد`.
+    pub omit_one: bool,
+}
+
+pub const DINAR: Noun = Noun {
+    singular: "دينار",
+    accusative: "دينارًا",
+    dual_nom: "ديناران",
+    dual_obl: "دينارين",
+    plural: "دنانير",
+    gender: Gender::Masculine,
+    omit_one: false,
+};
+
+pub const CENTIME: Noun = Noun {
+    singular: "سنتيم",
+    accusative: "سنتيمًا",
+    dual_nom: "سنتيمان",
+    dual_obl: "سنتيمين",
+    plural: "سنتيمات",
+    gender: Gender::Masculine,
+    omit_one: false,
+};
+
+/// A feminine noun, as an example of feminine agreement (Lebanese/Syrian pound).
+pub const LIRA: Noun = Noun {
+    singular: "ليرة",
+    accusative: "ليرةً",
+    dual_nom: "ليرتان",
+    dual_obl: "ليرتين",
+    plural: "ليرات",
+    gender: Gender::Feminine,
+    omit_one: false,
+};
+
+const THOUSAND: Noun = Noun {
+    singular: "ألف",
+    accusative: "ألفًا",
+    dual_nom: "ألفان",
+    dual_obl: "ألفين",
+    plural: "آلاف",
+    gender: Gender::Masculine,
+    omit_one: true,
+};
+
+const MILLION: Noun = Noun {
+    singular: "مليون",
+    accusative: "مليونًا",
+    dual_nom: "مليونان",
+    dual_obl: "مليونين",
+    plural: "ملايين",
+    gender: Gender::Masculine,
+    omit_one: true,
+};
+
+const BILLION: Noun = Noun {
+    singular: "مليار",
+    accusative: "مليارًا",
+    dual_nom: "ملياران",
+    dual_obl: "مليارين",
+    plural: "مليارات",
+    gender: Gender::Masculine,
+    omit_one: true,
+};
+
+/// Currency: a main unit and a hundredth.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Currency {
+    pub unit: Noun,
+    pub sub: Noun,
+}
+
+pub const DZD: Currency = Currency { unit: DINAR, sub: CENTIME };
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct Options {
+    pub case: Case,
+    /// Gender for bare numbers (no counted noun).
+    pub gender: Gender,
+    /// Spell hundreds `مئة` instead of `مائة`.
+    pub mia_spelling: bool,
+}
+
+/// Units 1..=10 in the form used with a noun of gender `g`
+/// (3–10 take the opposite gender: masculine noun → `ثلاثة`).
+fn unit(n: u64, g: Gender, case: Case) -> &'static str {
+    let masc_noun = g == Gender::Masculine;
+    match (n, masc_noun, case.oblique()) {
+        (1, true, _) => "واحد",
+        (1, false, _) => "واحدة",
+        (2, true, false) => "اثنان",
+        (2, true, true) => "اثنين",
+        (2, false, false) => "اثنتان",
+        (2, false, true) => "اثنتين",
+        (n, true, _) => ["", "", "", "ثلاثة", "أربعة", "خمسة", "ستة", "سبعة", "ثمانية", "تسعة", "عشرة"][n as usize],
+        (n, false, _) => ["", "", "", "ثلاث", "أربع", "خمس", "ست", "سبع", "ثماني", "تسع", "عشر"][n as usize],
+    }
+}
+
+fn tens(t: u64, case: Case) -> &'static str {
+    let nom = ["", "", "عشرون", "ثلاثون", "أربعون", "خمسون", "ستون", "سبعون", "ثمانون", "تسعون"];
+    let obl = ["", "", "عشرين", "ثلاثين", "أربعين", "خمسين", "ستين", "سبعين", "ثمانين", "تسعين"];
+    if case.oblique() {
+        obl[t as usize]
+    } else {
+        nom[t as usize]
+    }
+}
+
+/// 1..=99 as a bare numeral agreeing with a noun of gender `g`.
+fn below_100(n: u64, g: Gender, case: Case) -> String {
+    let masc = g == Gender::Masculine;
+    match n {
+        1..=10 => unit(n, g, case).to_string(),
+        11 => (if masc { "أحد عشر" } else { "إحدى عشرة" }).to_string(),
+        12 => match (masc, case.oblique()) {
+            (true, false) => "اثنا عشر",
+            (true, true) => "اثني عشر",
+            (false, false) => "اثنتا عشرة",
+            (false, true) => "اثنتي عشرة",
+        }
+        .to_string(),
+        13..=19 => format!("{} {}", unit(n - 10, g, case), if masc { "عشر" } else { "عشرة" }),
+        _ => {
+            let (t, u) = (n / 10, n % 10);
+            match u {
+                0 => tens(t, case).to_string(),
+                1 => format!("{} و{}", if masc { "واحد" } else { "إحدى" }, tens(t, case)),
+                _ => format!("{} و{}", unit(u, g, case), tens(t, case)),
+            }
+        }
+    }
+}
+
+/// Hundreds word for h (1..=9). `construct`: a noun follows directly (`مائتا دينار`).
+fn hundreds(h: u64, case: Case, construct: bool) -> &'static str {
+    match (h, case.oblique(), construct) {
+        (1, ..) => "مائة",
+        (2, false, false) => "مائتان",
+        (2, true, false) => "مائتين",
+        (2, false, true) => "مائتا",
+        (2, true, true) => "مائتي",
+        (h, ..) => ["", "", "", "ثلاثمائة", "أربعمائة", "خمسمائة", "ستمائة", "سبعمائة", "ثمانمائة", "تسعمائة"][h as usize],
+    }
+}
+
+fn dual(noun: &Noun, case: Case, construct: bool) -> String {
+    let d = if case.oblique() { noun.dual_obl } else { noun.dual_nom };
+    if construct {
+        d.strip_suffix('ن').unwrap_or(d).to_string()
+    } else {
+        d.to_string()
+    }
+}
+
+/// 1..=99 of `noun`. `construct`: another noun follows directly (`ألف دينار`).
+fn count_small(r: u64, noun: &Noun, case: Case, construct: bool) -> String {
+    match r {
+        1 if noun.omit_one => noun.singular.to_string(),
+        1 => format!("{} {}", noun.singular, unit(1, noun.gender, case)),
+        2 => dual(noun, case, construct),
+        3..=10 => format!("{} {}", below_100(r, noun.gender, case), noun.plural),
+        _ => {
+            let n = if construct { noun.singular } else { noun.accusative };
+            format!("{} {n}", below_100(r, noun.gender, case))
+        }
+    }
+}
+
+/// 1..=999 of `noun`.
+fn count(g: u64, noun: &Noun, case: Case, construct: bool) -> String {
+    let (h, r) = (g / 100, g % 100);
+    match (h, r) {
+        (0, r) => count_small(r, noun, case, construct),
+        (h, 0) => format!("{} {}", hundreds(h, case, true), noun.singular),
+        // `مائة ألف وألف`: the hundreds keep their own noun when 1 or 2 follows.
+        (h, 1 | 2) => format!("{} {} و{}", hundreds(h, case, true), noun.singular, count_small(r, noun, case, construct)),
+        (h, r) => format!("{} و{}", hundreds(h, case, false), count_small(r, noun, case, construct)),
+    }
+}
+
+/// 1..=999 as a bare numeral.
+fn bare_below_1000(n: u64, g: Gender, case: Case) -> String {
+    let (h, r) = (n / 100, n % 100);
+    match (h, r) {
+        (0, r) => below_100(r, g, case),
+        (h, 0) => hundreds(h, case, false).to_string(),
+        (h, r) => format!("{} و{}", hundreds(h, case, false), below_100(r, g, case)),
+    }
+}
+
+fn groups(n: u64) -> [(u64, Option<&'static Noun>); 4] {
+    [
+        (n / 1_000_000_000, Some(&BILLION)),
+        ((n / 1_000_000) % 1000, Some(&MILLION)),
+        ((n / 1000) % 1000, Some(&THOUSAND)),
+        (n % 1000, None),
+    ]
+}
+
+fn finish(s: String, opts: &Options) -> String {
+    if opts.mia_spelling {
+        s.replace("مائ", "مئ")
+    } else {
+        s
+    }
+}
+
+/// Spell `n` as a bare Arabic numeral (no counted noun).
+pub fn number(n: u64, opts: &Options) -> Result<String, Error> {
+    if n > MAX {
+        return Err(Error::TooLarge(n));
+    }
+    if n == 0 {
+        return Ok("صفر".into());
+    }
+    let parts: Vec<String> = groups(n)
+        .iter()
+        .filter(|(g, _)| *g > 0)
+        .map(|&(g, scale)| match scale {
+            Some(noun) => count(g, noun, opts.case, false),
+            None => bare_below_1000(g, opts.gender, opts.case),
+        })
+        .collect();
+    Ok(finish(parts.join(" و"), opts))
+}
+
+/// Spell `n` followed by its counted noun, with full agreement.
+pub fn with_noun(n: u64, noun: &Noun, opts: &Options) -> Result<String, Error> {
+    if n > MAX {
+        return Err(Error::TooLarge(n));
+    }
+    Ok(finish(with_noun_raw(n, noun, opts.case), opts))
+}
+
+fn with_noun_raw(n: u64, noun: &Noun, case: Case) -> String {
+    if n == 0 {
+        return format!("صفر {}", noun.singular);
+    }
+    let r = n % 100;
+    if n > 100 && (r == 1 || r == 2) {
+        // "ألف دينار ودينار واحد": the round part carries its own noun.
+        return format!("{} و{}", with_noun_raw(n - r, noun, case), count_small(r, noun, case, false));
+    }
+    let gs = groups(n);
+    let units = gs[3].0;
+    let last_scale = gs.iter().rposition(|&(g, s)| g > 0 && s.is_some());
+    let mut parts = Vec::new();
+    for (i, &(g, scale)) in gs.iter().enumerate() {
+        if g == 0 {
+            continue;
+        }
+        parts.push(match scale {
+            Some(s) => count(g, s, case, units == 0 && Some(i) == last_scale),
+            None => count(g, noun, case, false),
+        });
+    }
+    let mut s = parts.join(" و");
+    if units == 0 {
+        s.push(' ');
+        s.push_str(noun.singular);
+    }
+    s
+}
+
+/// `1234.50 DZD` → `ألف ومائتان وأربعة وثلاثون دينارًا وخمسون سنتيمًا`.
+pub fn amount(units: u64, cents: u32, cur: &Currency, opts: &Options) -> Result<String, Error> {
+    if cents > 99 {
+        return Err(Error::BadCents(cents));
+    }
+    let main = with_noun(units, &cur.unit, opts)?;
+    if cents == 0 {
+        return Ok(main);
+    }
+    let sub = with_noun(cents as u64, &cur.sub, opts)?;
+    Ok(if units == 0 { sub } else { format!("{main} و{sub}") })
+}

tafqit-0.1.0/src/fr.rs

@@ -0,0 +1,188 @@
+//! French number words (traditional spelling by default, or the 1990
+//! "rectified" spelling with hyphens everywhere).
+
+use crate::{Error, Gender, MAX};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum Spelling {
+    /// Hyphens only between tens and units below 100 (`deux cent vingt et un`).
+    #[default]
+    Traditional,
+    /// 1990 rectifications: hyphens between all numerals (`deux-cent-vingt-et-un`);
+    /// `million`/`milliard` are nouns and stay separate words.
+    Rectified1990,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct Options {
+    pub spelling: Spelling,
+    /// Gender of the counted noun: `un`/`une` (also in `vingt et une`).
+    pub gender: Gender,
+}
+
+const UNITS: [&str; 17] = [
+    "zéro", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "onze", "douze", "treize",
+    "quatorze", "quinze", "seize",
+];
+const TENS: [&str; 7] = ["", "", "vingt", "trente", "quarante", "cinquante", "soixante"];
+
+/// 1..=99 as a list of words; `last` means nothing follows in the whole number
+/// (needed for the plural of `quatre-vingts`). `fem` turns a final `un` into `une`.
+fn below_100(n: u64, last: bool, fem: bool, sp: Spelling) -> Vec<String> {
+    debug_assert!((1..100).contains(&n));
+    let join = |a: &str, b: &str| format!("{a}-{b}");
+    let one = if fem { "une" } else { "un" };
+    let w = match n {
+        1 => one.to_string(),
+        2..=16 => UNITS[n as usize].to_string(),
+        17..=19 => join("dix", UNITS[n as usize - 10]),
+        20..=69 => {
+            let (t, u) = (n / 10, n % 10);
+            match u {
+                0 => TENS[t as usize].to_string(),
+                1 => match sp {
+                    Spelling::Traditional => return vec![TENS[t as usize].into(), "et".into(), one.into()],
+                    Spelling::Rectified1990 => format!("{}-et-{one}", TENS[t as usize]),
+                },
+                _ => join(TENS[t as usize], UNITS[u as usize]),
+            }
+        }
+        70..=79 => {
+            let r = n - 60;
+            if r == 11 {
+                match sp {
+                    Spelling::Traditional => return vec!["soixante".into(), "et".into(), "onze".into()],
+                    Spelling::Rectified1990 => "soixante-et-onze".into(),
+                }
+            } else {
+                join("soixante", &below_100(r, last, fem, sp).join("-"))
+            }
+        }
+        80 => (if last { "quatre-vingts" } else { "quatre-vingt" }).to_string(),
+        81..=99 => join("quatre-vingt", &below_100(n - 80, last, fem, sp).join("-")),
+        _ => unreachable!(),
+    };
+    vec![w]
+}
+
+/// 1..=999 as words. `last`: nothing follows (affects `cents`/`vingts`).
+/// `before_noun`: followed by `million(s)`/`milliard(s)` (a noun, so `cents` keeps its s).
+fn below_1000(n: u64, last: bool, before_noun: bool, fem: bool, sp: Spelling) -> Vec<String> {
+    let (h, r) = (n / 100, n % 100);
+    let mut out = Vec::new();
+    if h > 0 {
+        if h > 1 {
+            out.push(UNITS[h as usize].to_string());
+        }
+        let plural = h > 1 && r == 0 && (last || before_noun);
+        out.push(if plural { "cents" } else { "cent" }.to_string());
+    }
+    if r > 0 {
+        out.extend(below_100(r, last || before_noun, fem, sp));
+    }
+    out
+}
+
+/// Spell `n` (0..=999_999_999_999) in French.
+pub fn number(n: u64, opts: &Options) -> Result<String, Error> {
+    if n > MAX {
+        return Err(Error::TooLarge(n));
+    }
+    if n == 0 {
+        return Ok("zéro".into());
+    }
+    let sp = opts.spelling;
+    let groups = [(n / 1_000_000_000, "milliard"), ((n / 1_000_000) % 1000, "million"), ((n / 1000) % 1000, "mille"), (n % 1000, "")];
+    // Each scale part is a word list; parts are joined with spaces, and with
+    // hyphens around `mille` in rectified spelling.
+    let mut parts: Vec<String> = Vec::new();
+    for &(g, scale) in &groups {
+        if g == 0 {
+            continue;
+        }
+        let fem = opts.gender == Gender::Feminine && scale.is_empty();
+        match scale {
+            "milliard" | "million" => {
+                let w = below_1000(g, false, true, false, sp);
+                let noun = if g > 1 { format!("{scale}s") } else { scale.to_string() };
+                parts.push(format!("{} {noun}", join_words(&w, sp)));
+            }
+            "mille" => {
+                // "mille", never "un mille"; invariable.
+                let mut w = if g == 1 { vec![] } else { below_1000(g, false, false, false, sp) };
+                w.push("mille".into());
+                parts.push(join_words(&w, sp));
+            }
+            _ => parts.push(join_words(&below_1000(g, true, false, fem, sp), sp)),
+        }
+    }
+    Ok(match sp {
+        Spelling::Traditional => parts.join(" "),
+        Spelling::Rectified1990 => {
+            // Hyphenate between numerals, but keep spaces around million(s)/milliard(s).
+            let mut s = String::new();
+            for (i, p) in parts.iter().enumerate() {
+                if i > 0 {
+                    let prev_is_noun = parts[i - 1].ends_with("million")
+                        || parts[i - 1].ends_with("millions")
+                        || parts[i - 1].ends_with("milliard")
+                        || parts[i - 1].ends_with("milliards");
+                    s.push(if prev_is_noun { ' ' } else { '-' });
+                }
+                s.push_str(p);
+            }
+            s
+        }
+    })
+}
+
+fn join_words(w: &[String], sp: Spelling) -> String {
+    match sp {
+        Spelling::Traditional => w.join(" "),
+        Spelling::Rectified1990 => w.join("-"),
+    }
+}
+
+/// French currency names.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Currency {
+    pub unit: (&'static str, &'static str),
+    pub unit_gender: Gender,
+    pub sub: (&'static str, &'static str),
+    pub sub_gender: Gender,
+    /// Elided form of "de" before the unit (`d'euros`), if the unit starts with a vowel.
+    pub elide: bool,
+}
+
+pub const DINAR: Currency = Currency {
+    unit: ("dinar", "dinars"),
+    unit_gender: Gender::Masculine,
+    sub: ("centime", "centimes"),
+    sub_gender: Gender::Masculine,
+    elide: false,
+};
+
+fn with_noun(n: u64, noun: (&str, &str), gender: Gender, elide: bool, opts: &Options) -> Result<String, Error> {
+    let words = number(n, &Options { gender, ..*opts })?;
+    let name = if n >= 2 { noun.1 } else { noun.0 };
+    // "un million de dinars": a round number of millions/billions takes "de".
+    let de = n >= 1_000_000 && n.is_multiple_of(1_000_000);
+    Ok(match (de, elide) {
+        (true, true) => format!("{words} d'{name}"),
+        (true, false) => format!("{words} de {name}"),
+        _ => format!("{words} {name}"),
+    })
+}
+
+/// `1234.50 DZD` → `mille deux cent trente-quatre dinars et cinquante centimes`.
+pub fn amount(units: u64, cents: u32, cur: &Currency, opts: &Options) -> Result<String, Error> {
+    if cents > 99 {
+        return Err(Error::BadCents(cents));
+    }
+    let main = with_noun(units, cur.unit, cur.unit_gender, cur.elide, opts)?;
+    if cents == 0 {
+        return Ok(main);
+    }
+    let sub = with_noun(cents as u64, cur.sub, cur.sub_gender, false, opts)?;
+    Ok(if units == 0 { sub } else { format!("{main} et {sub}") })
+}

tafqit-0.1.0/src/lib.rs

@@ -0,0 +1,150 @@
+//! Tafqit (تفقيط): write numbers and money amounts in words, in Arabic and
+//! French, for invoices and cheques. Dinar/centime forms are built in.
+//!
+//! ```
+//! use tafqit::{ar, fr, Amount};
+//!
+//! let a: Amount = "1234.50".parse().unwrap();
+//! assert_eq!(
+//!     a.to_arabic(&ar::DZD, &ar::Options::default()).unwrap(),
+//!     "ألف ومائتان وأربعة وثلاثون دينارًا وخمسون سنتيمًا"
+//! );
+//! assert_eq!(
+//!     a.to_french(&fr::DINAR, &fr::Options::default()).unwrap(),
+//!     "mille deux cent trente-quatre dinars et cinquante centimes"
+//! );
+//! assert_eq!(ar::number(2000, &Default::default()).unwrap(), "ألفان");
+//! ```
+
+pub mod ar;
+pub mod fr;
+
+use std::fmt;
+use std::str::FromStr;
+
+/// Largest supported number: 999 999 999 999 (up to the billions).
+pub const MAX: u64 = 999_999_999_999;
+
+/// Grammatical gender of the counted noun.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum Gender {
+    #[default]
+    Masculine,
+    Feminine,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Error {
+    TooLarge(u64),
+    BadCents(u32),
+    Parse(String),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::TooLarge(n) => write!(f, "{n} is too large (max {MAX})"),
+            Error::BadCents(c) => write!(f, "invalid hundredths: {c} (must be 0..=99)"),
+            Error::Parse(s) => write!(f, "cannot parse amount: {s}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+/// A money amount: whole units plus hundredths.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct Amount {
+    pub units: u64,
+    pub cents: u32,
+}
+
+impl Amount {
+    pub fn new(units: u64, cents: u32) -> Result<Amount, Error> {
+        if cents > 99 {
+            return Err(Error::BadCents(cents));
+        }
+        if units > MAX {
+            return Err(Error::TooLarge(units));
+        }
+        Ok(Amount { units, cents })
+    }
+
+    pub fn to_arabic(&self, cur: &ar::Currency, opts: &ar::Options) -> Result<String, Error> {
+        ar::amount(self.units, self.cents, cur, opts)
+    }
+
+    pub fn to_french(&self, cur: &fr::Currency, opts: &fr::Options) -> Result<String, Error> {
+        fr::amount(self.units, self.cents, cur, opts)
+    }
+
+    /// Cheque wording: `فقط ... لا غير`.
+    pub fn to_arabic_cheque(&self, cur: &ar::Currency, opts: &ar::Options) -> Result<String, Error> {
+        Ok(format!("فقط {} لا غير", self.to_arabic(cur, opts)?))
+    }
+}
+
+impl FromStr for Amount {
+    type Err = Error;
+
+    /// Accepts `1234`, `1234.5`, `1234,50`, `1 234,50`, `1,234.50`, `1_234.50`.
+    /// With both `,` and `.`, the last one is the decimal separator.
+    /// At most two decimals; no rounding is done.
+    fn from_str(s: &str) -> Result<Amount, Error> {
+        let err = || Error::Parse(s.to_string());
+        let cleaned: String = s.trim().chars().filter(|c| !matches!(c, ' ' | '_' | '\'' | '\u{a0}' | '\u{202f}')).collect();
+        if cleaned.is_empty() {
+            return Err(err());
+        }
+        let dec_pos = cleaned.rfind(['.', ',']);
+        let (int_part, frac) = match dec_pos {
+            Some(p) => {
+                let frac = &cleaned[p + 1..];
+                // "1,234" (three digits after a lone comma/dot, no other separator) is a thousands separator.
+                let other_sep = cleaned[..p].contains(['.', ',']);
+                if frac.len() == 3 && !other_sep && frac.chars().all(|c| c.is_ascii_digit()) {
+                    (cleaned.replace([',', '.'], ""), String::new())
+                } else {
+                    (cleaned[..p].replace([',', '.'], ""), frac.to_string())
+                }
+            }
+            None => (cleaned.clone(), String::new()),
+        };
+        if int_part.is_empty() && frac.is_empty() {
+            return Err(err());
+        }
+        if !int_part.chars().all(|c| c.is_ascii_digit()) || !frac.chars().all(|c| c.is_ascii_digit()) || frac.len() > 2 {
+            return Err(err());
+        }
+        let units: u64 = if int_part.is_empty() { 0 } else { int_part.parse().map_err(|_| err())? };
+        let cents: u32 = match frac.len() {
+            0 => 0,
+            1 => frac.parse::<u32>().unwrap() * 10,
+            _ => frac.parse().unwrap(),
+        };
+        Amount::new(units, cents)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_amounts() {
+        let ok = |s: &str, u: u64, c: u32| assert_eq!(s.parse::<Amount>(), Ok(Amount { units: u, cents: c }), "{s}");
+        ok("1234", 1234, 0);
+        ok("1234.5", 1234, 50);
+        ok("1234,05", 1234, 5);
+        ok("1 234,50", 1234, 50);
+        ok("1,234.50", 1234, 50);
+        ok("1.234,50", 1234, 50);
+        ok("1,234", 1234, 0);
+        ok("12.345", 12345, 0); // lone separator + 3 digits = thousands
+        ok("1_000_000", 1_000_000, 0);
+        ok(".75", 0, 75);
+        for bad in ["", "abc", "1.234.5x", "12.3456", "-5", "1e3", "1000000000000"] {
+            assert!(bad.parse::<Amount>().is_err(), "{bad} should fail");
+        }
+    }
+}

tafqit-0.1.0/src/main.rs

@@ -0,0 +1,100 @@
+use std::process::ExitCode;
+use tafqit::{ar, fr, Amount, Gender};
+
+const USAGE: &str = "usage: tafqit [options] <amount>
+
+options:
+  --lang ar|fr|both     output language(s) (default: both)
+  --number              spell a bare number, no currency
+  --case nom|acc|gen    Arabic grammatical case (default: nom)
+  --feminine            feminine counted noun (bare numbers; French une)
+  --cheque              Arabic cheque wording: فقط ... لا غير
+  --rectified           French 1990 spelling (hyphens everywhere)
+  --mia                 Arabic spelling مئة instead of مائة
+
+examples:
+  tafqit 1234.50
+  tafqit --lang ar --cheque 2000000
+  tafqit --number --feminine 21";
+
+fn main() -> ExitCode {
+    let mut lang = "both".to_string();
+    let mut bare = false;
+    let mut cheque = false;
+    let mut aro = ar::Options::default();
+    let mut fro = fr::Options::default();
+    let mut amount: Option<String> = None;
+    let mut args = std::env::args().skip(1);
+    while let Some(a) = args.next() {
+        match a.as_str() {
+            "--lang" => lang = args.next().unwrap_or_default(),
+            "--number" => bare = true,
+            "--cheque" => cheque = true,
+            "--feminine" => {
+                aro.gender = Gender::Feminine;
+                fro.gender = Gender::Feminine;
+            }
+            "--rectified" => fro.spelling = fr::Spelling::Rectified1990,
+            "--mia" => aro.mia_spelling = true,
+            "--case" => {
+                aro.case = match args.next().as_deref() {
+                    Some("nom") => ar::Case::Nominative,
+                    Some("acc") => ar::Case::Accusative,
+                    Some("gen") => ar::Case::Genitive,
+                    _ => return usage(),
+                }
+            }
+            "-h" | "--help" => {
+                println!("{USAGE}");
+                return ExitCode::SUCCESS;
+            }
+            s if amount.is_none() && !s.starts_with("--") => amount = Some(s.to_string()),
+            _ => return usage(),
+        }
+    }
+    let Some(raw) = amount else { return usage() };
+    let a: Amount = match raw.parse() {
+        Ok(a) => a,
+        Err(e) => {
+            eprintln!("tafqit: {e}");
+            return ExitCode::from(1);
+        }
+    };
+    if bare && a.cents != 0 {
+        eprintln!("tafqit: --number takes a whole number");
+        return ExitCode::from(1);
+    }
+    let arabic = || -> Result<String, tafqit::Error> {
+        match (bare, cheque) {
+            (true, _) => ar::number(a.units, &aro),
+            (false, true) => a.to_arabic_cheque(&ar::DZD, &aro),
+            (false, false) => a.to_arabic(&ar::DZD, &aro),
+        }
+    };
+    let french = || if bare { fr::number(a.units, &fro) } else { a.to_french(&fr::DINAR, &fro) };
+    let mut outputs = Vec::new();
+    if lang == "ar" || lang == "both" {
+        outputs.push(arabic());
+    }
+    if lang == "fr" || lang == "both" {
+        outputs.push(french());
+    }
+    if outputs.is_empty() {
+        return usage();
+    }
+    for o in outputs {
+        match o {
+            Ok(s) => println!("{s}"),
+            Err(e) => {
+                eprintln!("tafqit: {e}");
+                return ExitCode::from(1);
+            }
+        }
+    }
+    ExitCode::SUCCESS
+}
+
+fn usage() -> ExitCode {
+    eprintln!("{USAGE}");
+    ExitCode::from(2)
+}