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
49
50
51
52
53
54

/// Usage of [`FuncMap`] to "deeply" convert from relative to absolute paths
/// using newtype wrappers
use funcmap::FuncMap;
use paths::*;

/// Example data structure illustrating the use of [`FuncMap`]
/// `T` is meant to be either [`RelativePath<P>`] or [`AbsolutePath<P>`] where
/// `P: AsRef<Path>`
#[derive(FuncMap, Debug)]
struct FilePaths<T> {
    manifest_path: T,
    src_paths: Vec<T>,
}

fn main() {
    let relative_paths = FilePaths::<RelativePath<_>> {
        manifest_path: "Cargo.toml".into(),
        src_paths: vec!["src/lib.rs".into(), "src/main.rs".into()],
    };

    let base_path = "my_project";
    let absolute_paths = relative_paths.func_map(|rel_path| rel_path.to_absolute(base_path));

    println!("{:?}", absolute_paths);
}

/// Helpers dealing with absolute and relative paths
mod paths {
    use std::path::{Path, PathBuf};

    #[derive(Debug)]
    pub struct AbsolutePath<P>(P);

    #[derive(Debug)]
    pub struct RelativePath<P>(P);

    impl<P> From<P> for RelativePath<P> {
        fn from(path: P) -> Self {
            Self(path)
        }
    }

    impl<P> RelativePath<P>
    where
        P: AsRef<Path>,
    {
        pub fn to_absolute<Q>(&self, base_path: Q) -> AbsolutePath<PathBuf>
        where
            Q: AsRef<Path>,
        {
            AbsolutePath(base_path.as_ref().join(&self.0))
        }
    }
}