The guard Haskell Alternative function brought to Rust

The [guard!] macro.

The [guard!] macro implements a control-flow sugar that occurs very often in common Rust code:

``` fn foo(cond: bool) -> Option { if !cond { return None; }

// do something useful

Some(42) } ```

This pattern of testing arguments and early-returning with an error is very typical. Unfortunately, the [?] operator doesn’t help us here because we want to early-return on a boolean value, not an error value.

A not very idiomatic and weird way to rewrite that:

fn foo(cond: bool) -> Option<i32> { if cond { Some(()) } else { None }?; Some(42) }

This crate provides the [guard!] macro — analoguous to the [guard] Haskell Alternative function — that helps early-return from a function if a predicate is false:

```

![feature(try_trait)]

use try_guard::guard;

fn foo(cond: bool) -> Option { guard!(cond); Some(42) } ```

Custom guard types

This crate also allows you to guard to any thing that implements [Try<Error = NoneError>]. For instance, the following works:

```

![feature(try_trait)]

use std::ops::Try; use std::option::NoneError; use try_guard::guard;

enum MyGuard { Just(T), Nothing }

impl MyGuard { fn new(x: T) -> Self { MyGuard::Just(x) }

fn none() -> Self { MyGuard::Nothing } }

impl Try for MyGuard { type Ok = T;

type Error = NoneError;

fn fromerror(: Self::Error) -> Self { MyGuard::none() }

fn from_ok(x: Self::Ok) -> Self { MyGuard::new(x) }

fn into_result(self) -> Result { match self { MyGuard::Just(x) => Ok(x), MyGuard::Nothing => Err(NoneError) } } }

fn foo(cond: bool) -> MyGuard { guard!(cond); MyGuard::new(42) }

```

Feature flags