1 unstable release
0.1.0 | May 26, 2020 |
---|
#6 in #yolo
8KB
yolo-block
Rust library providing yolo!
blocks, which are like try
blocks, except that they automatically unwrap the result. Effectively, inside a yolo!
block, the ?
operator functions as unwrap()
.
#![feature(try_blocks)]
use yolo_block::yolo;
use std::convert::TryFrom;
let result = yolo! {
"1".parse::<usize>()?
+ usize::try_from(2i32)?
+ [0,1,2,3].binary_search(&3)?
};
assert_eq!(result, 6);
// Panics with the message "YOLO'd an error: ParseIntError { kind: InvalidDigit }"
let result = yolo! {
"1".parse::<usize>()?
+ "foo".parse::<usize>()?
+ "3".parse::<usize>()?
};
Motivation
This crate was primarily written as a joke, but I can imagine a practical use for it. While prototyping, you may want to write code that will ultimately handle errors using the ?
operator, but you may not yet have designed the way to catch the errors. In this case, wrapping the code in a yolo!
block allows you write code that correctly uses ?
, rather than leaving unwrap()
calls that you will need to replace later.
Design and features
The yolo!
macro uses a try
block internally. try
blocks are an unstable feature (as of this writing – Rust 1.43.1), so this crate is only available on nightly, and you must enable #![feature(try_blocks)]
in the crate where you use it.
yolo-block
is fully compatible with #![no_std]
(and #![no_implicit_prelude]
).
A single yolo!
block can handle multiple error types. Those error types can be any type that implements Debug. No extra type annotations are needed.
Internally, we use a custom error type that can be converted from anything that implements Debug. In order to handle disparate types without having to construct a Box<dyn Debug>
, the From
conversion simply panics immediately. The custom error type is actually uninhabited.
License
Licensed under either of
- Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
at your option.
Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.