fromage 0.1.1

A cheesy Rust hack for converting between non-local types
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use fromage::{Fromage, Intoage, TryFromage, TryIntoage};
use non_local::{Bar, Foo};

struct X;

impl Fromage<Foo, X> for Bar {
    fn fromage(_value: Foo) -> Self {
        Bar
    }
}

impl Fromage<String, X> for usize {
    fn fromage(value: String) -> Self {
        value.len()
    }
}

impl TryFromage<Foo, X> for Bar {
    type Error = ();

    fn try_fromage(_value: Foo) -> Result<Self, Self::Error> {
        Ok(Bar)
    }
}

impl TryFromage<String, X> for usize {
    type Error = ();

    fn try_fromage(value: String) -> Result<Self, Self::Error> {
        Ok(value.len())
    }
}

#[test]
fn test_fromage() {
    assert_eq!(Bar, Bar::fromage(Foo));
    assert_eq!(5_usize, usize::fromage(String::from("hello")));
}

#[test]
fn test_intoage() {
    assert_eq!(Bar, Foo.intoage());
    assert_eq!(12_usize, String::from("hello, world").intoage());
}

#[test]
fn test_intoage_reflexive() {
    assert_eq!(Bar, Bar.intoage());
    assert_eq!(5_usize, 5_usize.intoage());
}

#[test]
fn test_try_fromage() {
    assert_eq!(Bar, Bar::try_fromage(Foo).unwrap());
    assert_eq!(0_usize, usize::try_fromage(String::new()).unwrap());
}

#[test]
fn test_try_intoage() {
    assert_eq!(Bar, Foo.try_intoage().unwrap());
    assert_eq!(5_usize, String::from("hello").try_intoage().unwrap());
}

#[test]
fn test_try_intoage_reflexive() {
    assert_eq!(Bar, Bar.try_intoage().unwrap());
    assert_eq!(5_usize, 5_usize.try_intoage().unwrap());
}

#[test]
fn test_impl_intoage() {
    fn intoage_foo(value: impl Intoage<Bar, X>) -> Bar {
        value.intoage()
    }
    assert_eq!(Bar, intoage_foo(Foo));
}

#[test]
fn test_impl_try_intoage() {
    fn try_intoage_foo(value: impl TryIntoage<Bar, X, Error = ()>) -> Result<Bar, ()> {
        value.try_intoage()
    }
    assert_eq!(Bar, try_intoage_foo(Foo).unwrap());
}

#[test]
fn test_collect_intoage() {
    let vec: Vec<Bar> = vec![Foo, Foo].into_iter().map(Intoage::intoage).collect();
    assert_eq!(vec.len(), 2);
    assert_eq!(vec[0], Bar);
    assert_eq!(vec[1], Bar);
}

#[test]
fn test_try_collect_intoage() {
    let vec: Vec<Bar> = vec![Foo, Foo]
        .into_iter()
        .map(TryIntoage::try_intoage)
        .collect::<Result<Vec<_>, _>>()
        .unwrap();
    assert_eq!(vec.len(), 2);
    assert_eq!(vec[0], Bar);
    assert_eq!(vec[1], Bar);
}