borrowme

The missing compositional borrowing for Rust.

This crate provides an attribute macro which helps you pair two types through compositional borrowing and ownership conversion. Roughly this means that you can convert a struct which has lifetimes into ones which does not and such as between the Word and OwnedWord structs here:

```rust

[derive(Debug, PartialEq, Eq)]

struct Word<'a> { text: &'a str, lang: Option<&'a str>, examples: Vec<&'a str>, }

[derive(Debug, PartialEq, Eq)]

struct OwnedWord { text: String, lang: Option, examples: Vec, } ```

Writing and maintaining the OwnedWord variant is labour intensive and error prone. Instead we can use the #[borrowme] attribute provided by this crate:

```rust use borrowme::borrowme;

[borrowme]

[derive(Debug, PartialEq, Eq)]

struct Word<'a> { text: &'a str, lang: Option<&'a str>, examples: Vec<&'a str>, } ```

See the #[borrowme] attribute for detailed documentation on how the attribute works.

```rust let text = String::from("Hello"); let lang = Some(String::from("eng")); let examples = vec![String::from("Hello World")];

let word = Word { text: "Hello World", lang: lang.asderef(), examples: examples.iter().map(|s| s.asstr()).collect(), };

let word2: OwnedWord = borrowme::toowned(&word); let word3: Word<'> = borrowme::borrow(&word2); assert_eq!(word3, word); ```

Rust comes with two sibling traits which both are responsible for converting something to an owned and a borrowed variant: ToOwned and Borrow.

These convert a type to a borrowed value to an owned one, let's think about it from a broader perspective: How to we convert a type which has lifetimes, to one which does not?

To this end this crate defines two similar traits: [ToOwned] and [Borrow]. These traits serve a similar purpose to the traits in std but are implemented differently. See their corresponding documentation for more details.