Butcher

An easy way to interact with Cowed structs and enums.

This crate provides the following functionalities for data wrapped in Cow:

• destructuring/pattern matching over structs and enums,
• iterating over collections, or any type that implements IntoIterator,
• flattening Cow,
• removing an indirection level Cow.

Destructuring/pattern matching

The Butcher trait can be used when it is necessary to destruture something wrapped in a Cow. Below is a simple example:

use std::borrow::Cow;
use butcher::Butcher;

#[derive(Butcher, Clone)]
struct MyNumberList {
    val: u32,
    next: Option<Box<MyNumberList>>,
}

fn destructure_list_elem(i: Cow<MyNumberList>) -> (Cow<u32>, Cow<Option<Box<MyNumberList>>>) {
    let ButcheredMyNumberList { val, next } = Butcher::butcher(i);

    (val, next)
}

This also allows pattern matching, as demonstrated in the following example:

use butcher::Butcher;
use std::borrow::Cow;

#[derive(Butcher, Clone)]
enum WebEvent {
    PageLoad,
    KeyPress(char),
    Paste(String),
    // or c-like structures.
    Click { x: i64, y: i64 },
}

fn print_action(i: Cow<WebEvent>) {
    match WebEvent::butcher(i) {
        ButcheredWebEvent::PageLoad => { /* ... */ },
        ButcheredWebEvent::KeyPress(key) => { /* ... */ },
        ButcheredWebEvent::Paste(pasted) => { /* ... */ },
        ButcheredWebEvent::Click { x, y } => { /* ... */ },
    }
}

The Butcher procedural macro can be derived for structs and for enums.

Iteration

Here is a demonstration of how to iterate over an object wrapped in a Cow:

use std::borrow::Cow;
use butcher::iterator::{CowIter, IntoCowIterator};

fn print_numbers(elems: Cow<[u32]>) {
    let mut iter = elems.into_cow_iter();

    for element in iter {
        // The type of element is Cow<u32>
        println!("{:?}", element);
    }
}

See the documentation of CowIter for more information.

Flattening

In some situations, the Butcher proc macro can generate tricky fields, such as nested Cow. The FlattenCow trait aims to remove such flattening.

Removing an indirection level

The AsDerefCow trait allows to transform a given Cow<T> into a Cow<<T as Deref>::Target>. This can be usefull when it is needed to transform a Cow<String> into Cow<str>.