kiam

("kiam" is "when" in Esperanto)

This crate entroduces when! macro which provides better syntax for if/else if/else chains. The syntax is similar to match.

(idea is borrowed from kotlin)

toml [dependencies] kiam = "0.1"

Usage

Usage is similar to the usage of match, but instead of patterns, branches are guarded by boolean expression:

rust kiam::when! { false => (), true => (), // ... }

_ can be used as a default branch (it's also required to use when! in expression possition):

```rust let x = kiam::when! { false => 0, _ => 1, };

assert_eq!(x, 1); ```

You can also use let <pat> = to match a pattern, but in difference with match you'll have to provide an expression for every pattern:

```rust let a = None; let b = Some(17); let fallible = || Err(());

let x = kiam::when! { let Some(x) = a => x, let Ok(x) = fallible() => x, let Some(x) = b => (x as u32) + 1, _ => 1, };

assert_eq!(x, 18); ```

Last notes: - You can also compare structure litetals without brackets (you can't do thif with if/else if/else chain) - You can mixup boolean-braches with pattern matching - Only one branch is executed (not to be confused with switch in C-like languages)

```rust let mut x = 0;

kiam::when! { let Ok(_) = Err::<(), _>(()) => x = 1, true => x = 2, true => x = 3, let Some(n) = Some(42) => x = n, };

assert_eq!(x, 2); ```

```compile_fail

[derive(PartialEq)]

struct Struct { a: i32 }

// This does not compile because of the ambiguity if Struct { a: 0 } == Struct { a: 0 } { // ... } ```

```rust

[derive(PartialEq)]

struct Struct { a: i32 }

kiam::when! { // This, on the other hand, compiles fine Struct { a: 0 } == Struct { a: 0 } => { // ... }, } ```