funcmap 0.1.8

Derivable functorial mappings for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/// Usage of [`FuncMap`] to perform a "deep" `to_owned`
use funcmap::FuncMap;

/// Example data structures illustrating the use of [`FuncMap`]
/// `T` is meant to be either `&str` or [`String`]
#[derive(FuncMap, Debug)]
struct Group<T> {
    name: T,
    members: Vec<Member<T>>,
}

#[derive(FuncMap, Debug)]
struct Member<T> {
    name: T,
}

fn main() {
    println!("{:?}", load_group());
}

/// Loads a [`Group`] from a data source, e.g. a file (here for the sake of
/// simplicity: from a local buffer)
fn load_group() -> Group<String> {
    // local buffer (could e.g. be loaded from a file, will be dropped when `load_group` returns)
    let buffer = String::from("Example Group:Member 1,Member 2");

    // parsed data, borrows from local variable `buffer`, cannot be returned
    let group = parse_group(&buffer);

    // use `func_map` to perform a "deep" `to_owned`, creating owned data that can be returned
    group.func_map(ToOwned::to_owned)
}

/// Parses a [`Group`] from a string slice
fn parse_group(input: &str) -> Group<&str> {
    let [group_name, member_names]: [&str; 2] =
        input.split(':').collect::<Vec<_>>().try_into().unwrap();

    let members = member_names
        .split(',')
        .map(|name| Member { name })
        .collect();

    Group {
        name: group_name,
        members,
    }
}