https://github.com/rstudio-tech/simple-bind
Line Simple bind with Rust
https://github.com/rstudio-tech/simple-bind
Last synced: 11 months ago
JSON representation
Line Simple bind with Rust
- Host: GitHub
- URL: https://github.com/rstudio-tech/simple-bind
- Owner: rstudio-tech
- License: apache-2.0
- Created: 2024-12-06T21:27:39.000Z (over 1 year ago)
- Default Branch: master
- Last Pushed: 2024-12-06T21:28:11.000Z (over 1 year ago)
- Last Synced: 2025-07-02T17:55:29.055Z (12 months ago)
- Language: Rust
- Size: 15.6 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# simple-bind: one-line non-exhaustive binds in Rust
[](https://travis-ci.org/willcrichton/simple-bind)
[](https://crates.io/crates/simple-bind)
[](https://docs.rs/simple-bind/)
**Nightly-only crate.**
```rust
// Here's a brief example that demonstrates how simple-bind works.
#![feature(proc_macro, pattern_parentheses, stmt_expr_attributes)]
extern crate simple_bind;
use simple_bind::bind;
fn main() {
enum A { Foo(i32), Bar };
// Let's say you have a variant of an enum.
let x = A::Foo(10);
// Previously, if you knew `x` was `Foo` and just wanted to access the inside,
// you had to do either:
let y = match x { A::Foo(y) => y, _ => unreachable!() };
// or...
let y = if let A::Foo(y) = x { y } else { unreachable!() };
// With simple-bind, you can instead do:
bind!{let A::Foo(y) = x;}
// No more nested match/if statements!
assert_eq!(y, 10);
}
```
## Setup
Use of this crate uses the unstable `proc_macro` API, so it requires nightly and a few feature gates.
Enable nightly on your repository:
```
rustup override set nightly
```
Add this line to your `cargo.toml`:
```toml
[dependencies]
simple-bind = "0.1.5"
```
To your main module file (`lib.rs` or `main.rs`), add:
```rust
#![feature(proc_macro, pattern_parentheses, stmt_expr_attributes)]
extern crate simple_bind;
```
Then wherever you want to use the macro, use normal imports (i.e. not `#[macro_use]`):
```rust
use simple_bind::bind;
```
## Examples
```rust
fn main() {
enum B { Quux(i32) };
enum A { Foo(i32), Bar{y: i32}, Baz(B) };
// Simple binds
bind!{let A::Foo(x) = A::Foo(10);}
// Struct binds
let s = A::Bar{y: 1};
bind!{let A::Bar{y} = s;}
// Nested binds
bind!{let A::Baz(B::Quux(x)) = A::Baz(B::Quux(10));}
// Reference binds
let mut s = A::Foo(10);
bind!{let &mut A::Foo(ref mut y) = &mut s;}
*y = 3;
}
```
## Issues
This implementation just covers cases I've run in to, and is not exhaustive to all possible binds. If you find a problem, feel free to submit an issue or a PR!