# enum_is

Procedural macro that generates `is_*` predicate methods for enum variants.

With `#[derive(EnumIs)]`, every variant of your enum gets an `is_<variant>()`
method (in `snake_case`) that returns `true` when `self` matches that variant.

Works with unit, tuple, and struct variants.

---

## Example

```rust
use enum_is::EnumIs;

#[derive(EnumIs, Debug)]
enum Mode {
    Fast,
    Normal,
    Slow,
}

fn handle(mode: Mode) {
    if mode.is_fast() {
        // handle fast mode
    }

    if mode.is_slow() {
        // handle slow mode
    }
}
```

Generated methods look like:

```rust
impl Mode {
    pub fn is_fast(&self) -> bool { /* ... */ }
    pub fn is_normal(&self) -> bool { /* ... */ }
    pub fn is_slow(&self) -> bool { /* ... */ }
}
```

---

## Installation

In your `Cargo.toml`:

```toml
[dependencies]
enum_is = "0.1"
```

Then:

```rust
use enum_is::EnumIs;
```

---

## Supported enums

`EnumIs` works with:

- **Unit variants**

  ```rust
  #[derive(EnumIs)]
  enum Status {
      Ok,
      Error,
  }

  let s = Status::Ok;
  assert!(s.is_ok());
  assert!(!s.is_error());
  ```

- **Tuple variants**

  ```rust
  #[derive(EnumIs)]
  enum Value {
      Int(i32),
      Pair(u8, u8),
  }

  let v = Value::Pair(1, 2);
  assert!(v.is_pair());
  assert!(!v.is_int());
  ```

- **Struct variants**

  ```rust
  #[derive(EnumIs)]
  enum Message {
      Ping,
      Data { id: u64, payload: Vec<u8> },
  }

  let m = Message::Data { id: 1, payload: vec![] };
  assert!(m.is_data());
  assert!(!m.is_ping());
  ```

---

## Naming rules

For each variant, `EnumIs` generates a method:

- Method name: `is_<variant_name_in_snake_case>`
- Example mappings:

  | Variant name       | Method name               |
  | ------------------ | ------------------------- |
  | `Fast`             | `is_fast()`               |
  | `PostOnly`         | `is_post_only()`          |
  | `CPU`              | `is_cpu()`                |
  | `HTTPRequestError` | `is_http_request_error()` |

The methods take `&self` and return `bool`.

Internally, the macro uses `matches!` with:

- `Self::Variant` for unit variants
- `Self::Variant(..)` for tuple variants
- `Self::Variant { .. }` for struct variants

---

## Limitations

- `#[derive(EnumIs)]` must be used on **enums** only.  
  Using it on a struct or union will produce a compile error.
- Method names are generated purely from the variant identifiers; there is no
  customization (attributes, renames, ignores) yet.
