parse-generics-poc 0.1.0

A proof-of-concept implementation of the proposed RFC #1583; provides macros for parsing generics and where clauses. Note: requires a compatible nightly compiler. For a stable alternative, see the parse-generics-shim crate.
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

/*
Copyright ⓒ 2016 rust-custom-derive contributors.

Licensed under the MIT license (see LICENSE or <http://opensource.org
/licenses/MIT>) or the Apache License, Version 2.0 (see LICENSE of
<http://www.apache.org/licenses/LICENSE-2.0>), at your option. All
files in the project carrying such notice may not be copied, modified,
or distributed except according to those terms.
*/
#![feature(plugin)]
#![plugin(parse_generics_poc)]

use std::fmt::Display;

macro_rules! wrap_fn {
    (
        as $wrap_name:ident,
        fn $fn_name:ident $($tail:tt)*
    ) => {
        parse_generics! {
            { constr, params, ltimes, tnames },
            then wrap_fn!(@expand $wrap_name, $fn_name,),
            $($tail)*
        }
    };

    (@as_item $i:item) => { $i };

    (
        @expand
        $wrap_name:ident,
        $fn_name:ident,
        {
            constr: [$($constr:tt)*],
            params: [$($params:tt)*],
            $($_generics_tail:tt)*
        },
        (
            $($arg_pats:ident: $arg_tys:ty),* $(,)*
        )
        $(-> $ret_ty:ty)* ;
        pre { $($pre:tt)* }
        post($res:ident) { $($post:tt)* }
    ) => {
        wrap_fn! {
            @as_item
            fn $wrap_name<$($constr)*>($($arg_pats: $arg_tys),*) $(-> $ret_ty)* {
                $($pre)*
                let $res = $fn_name::<$($params)*>($($arg_pats),*);
                $($post)*
            }
        }
    };
}

wrap_fn! {
    as wrap_to_string,
    fn to_string<T: Display>(v: T) -> String;
    pre {
        let prefix = String::from("wrap:");
    }
    post(result) {
        format!("{}{}", prefix, result)
    }
}

fn to_string<T: Display>(v: T) -> String {
    format!("{}", v)
}

#[test]
fn test_wrap_fn() {
    assert_eq!(&*wrap_to_string(42i32), "wrap:42");
}

trait Dummy<'a, T: ?Sized>: Sized {
    fn id(self) -> Self { self }
}

impl<'a> Dummy<'a, str> for &'a str {}

fn id<'a, T: ?Sized, U: ::Dummy<'a, T>>(v: U) -> U { v.id() }

wrap_fn! {
    as wrap_id,
    fn id<'a, T: ?Sized, U: ::Dummy<'a, T>>(v: U) -> U;
    pre {}
    post(result) { result }
}

#[test]
fn test_wrap_fn_id() {
    assert_eq!(wrap_id("hi!"), "hi!");
}