overloadable 0.4.1

Overloadable functions done easy in 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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#![feature(unboxed_closures, fn_traits)]
use std::fmt::Debug;
overloadable::overloadable! {
    pub(crate) func_name as
    fn(_: usize) {},
    fn<T>((x, y): (T, usize)) -> String where T: Debug {
        format!("{:?}, {:?}", x, y)
    },
    #[no_mangle]
    fn<'a, 'b: 'a>(a: &mut &'a str, b: &'b str) {
        *a = &b[..]
    }
}

#[test]
fn it_works() {
    assert_eq!(func_name((1, 2)), "1, 2");
    let a = "abc";
    {
        let mut b = "def";
        func_name(&mut b, a);
        assert_eq!(b, "abc");
    }
}

pub struct Foo1;

overloadable::overloadable_member! {
    pub Foo1::func_name as
    fn(_: usize) {},
    fn<T>((x, y): (T, usize)) -> String where T: Debug {
        format!("{:?}, {:?}", x, y)
    },
    #[no_mangle]
    fn<'a, 'b: 'a>(self, a: &mut &'a str, b: &'a str) {
        *a = &b[..]
    },
    fn(&self) -> usize {1}
}

//Forum example:
#[derive(Clone)]
enum Foo {
    A,
    B,
}
overloadable::overloadable_member! {
    Foo::my_func as
    fn(&self) -> &'static str {
        match self {
           Foo::A => "A",
           Foo::B => "B",
        }
    },
    fn(self, x: usize) -> Vec<Self> {
        let mut val = Vec::new();
        val.resize_with(x, || self.clone());
        val
    },
    fn() -> Box<Self> {
        Box::new(Foo::A)
    },
    fn(self: Box<Self>, other: Box<Self>) -> usize {
        match (&*self, &*other) {
            (Foo::A, Foo::A) => 2,
            (Foo::B, Foo::A) | (Foo::A, Foo::B) => 1,
            _ => 0
        }
    }
}