iri-rs-enum 3.3.6

Derive macro that maps vocabulary IRIs onto enum variants, with compile-time prefix resolution and const-friendly output.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

# iri-rs-enum

[![Crate](https://img.shields.io/crates/v/iri-rs-enum.svg?style=flat-square)](https://crates.io/crates/iri-rs-enum)
[![Docs](https://img.shields.io/docsrs/iri-rs-enum?style=flat-square)](https://docs.rs/iri-rs-enum)
[![MSRV](https://img.shields.io/crates/msrv/iri-rs-enum?style=flat-square)](https://crates.io/crates/iri-rs-enum)
[![License](https://img.shields.io/crates/l/iri-rs-enum.svg?style=flat-square)](#license)

`#[derive(IriEnum)]` for IRI-valued enum types, part of the [`iri-rs`](../iri-rs/) workspace. Fork of [`iref-enum`](https://crates.io/crates/iref-enum) by [Timothée Haudebourg](https://github.com/timothee-haudebourg/iref) — reworked to emit `const`-friendly output via `iri-rs-core`'s `from_raw_parts`.

Storing and comparing full IRIs is expensive when you only ever use a known vocabulary. `IriEnum` turns a plain Rust enum into a two-way map between an [`Iri`](../iri-rs-core/) and its variant — `TryFrom<&Iri<T>>` in, `From<&Variant>` to `Iri<&'static str>` out.

```rust
use iri_rs_core::Iri;
use iri_rs_enum::IriEnum;
use iri_rs_static::iri;

#[derive(IriEnum, PartialEq, Debug)]
#[iri_prefix("schema" = "https://schema.org/")]
pub enum Vocab {
    #[iri("schema:name")]  Name,
    #[iri("schema:knows")] Knows,
}

let term = Vocab::try_from(&iri!("https://schema.org/name")).unwrap();
assert_eq!(term, Vocab::Name);

let back: Iri<&'static str> = (&Vocab::Knows).into();
assert_eq!(back.as_str(), "https://schema.org/knows");
```

Prefixes resolve at macro expansion. Each variant's IRI is validated once against the real parser in [`iri-rs-core`](../iri-rs-core/) and emitted as a `const` from pre-computed component positions — no runtime parsing, no allocation.

---

## Install

Enable the `enum` feature on the facade crate (recommended):

```sh
cargo add iri-rs --features enum
```

or depend on this crate directly:

```sh
cargo add iri-rs-core iri-rs-enum iri-rs-static
```

The generated code references `::iri_rs_core::*`, so downstream crates must have `iri-rs-core` as a direct dependency.

## Attributes

| Attribute                             | Where   | Meaning                                        |
| ------------------------------------- | ------- | ---------------------------------------------- |
| `#[iri_prefix("ns" = "https://...")]` | Enum    | Declare a prefix usable in `#[iri(...)]`       |
| `#[iri("ns:term")]`                   | Variant | IRI for this variant (prefixed or absolute)    |

Multiple `#[iri_prefix]` attributes may be given on the same enum.

## Fallback variants

A variant with a single unnamed field acts as a catch-all. The inner type must implement `TryFrom<&Iri<T>>` and `From<&Inner>` for `Iri<&'static str>` — both are generated by this derive on nested enums, so fallbacks compose:

```rust,ignore
#[derive(IriEnum, PartialEq, Debug)]
#[iri_prefix("schema" = "https://schema.org/")]
pub enum Person {
    #[iri("schema:Person")] Base,
    Other(OtherVocab),   // fallback: try OtherVocab first
}
```

## Workspace

Part of the [`iri-rs`](https://github.com/mskvarc/iri-rs) workspace. See the [root README](../README.md) for the overall picture, motivation, and fork attribution.

## MSRV

Rust 1.85 (edition 2024).

## License

Dual-licensed:

- [Apache-2.0](../LICENSE-APACHE.md)
- [MIT](../LICENSE-MIT.md)