Library defining macros for calling blocks or expressions in a closure.

This library was mostly written to allow "safe navigation" with the ?. operator combination (seemingly) without jumping out of the current function. This allows a similar use of the operator as in other languages (such as Swift, C# or Kotlin).

To use this library, you have to add it to the dependencies of your Cargo.toml file

[dependencies]
fn_block = "0.2.1"

Then add the following lines to your module:

#[macro_use]
extern crate fn_block;
use fn_block::*;

Instead of the wildcard, you can also just import the symbols you need.

Here is an example on how to use the crate:

let o = Some("Foobar");
let s = fn_expr!{ o?.get(0..3)?.to_lowercase().into_some() };
assert_eq!("foo", s.unwrap());

Please visit the API Documentation for more details.

In short, this crate provides the following APIs:

• The fn_expr macro allows wrapping an expression into a lambda that is directly called.
• The IntoSome trait, which is implemented for all Sized types, allows to call into_some on a value to move it into an Option::Some.
• The IntoOk trait, which is implemented for all Sized types, allows to call into_ok on a value to move it into an Result::Ok.

For more examples, please have a look at the test module.

To use unstable features, the dependency declaration in your Cargo.toml has to be updated:

[dependencies]
fn_block = { version = "0.2.1", features = ["unproven"] }

Note that this crate's unstable features do work on stable Rust.

The following unstable APIs are available:

• The fn_try macro allows wrapping an expression into a lambda, being called directly and recover from errors directly afterwards.

The fn_block crate is licensed under the following licenses:

• Apache License, Version 2.0, (LICENSE-APACHE / http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT / http://opensource.org/licenses/MIT)

Choose under which you want to use the library.