git_function_history 0.7.0

show function history from git
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::error::Error;
use std::fmt::Debug;
pub fn empty_test() {

}

pub fn not_empty_test() {
    println!("not empty test");
    println!("{{ {} added more chages", "{");
}

#[derive(Debug)]
pub struct Test<a> {
    pub contents: String,
    pub history: Vec<a>,
}

impl<a>Test<a: Debug>  {
    /// empty test
    pub fn empty_test<'a>() {
        println!("empty test");
    }

    pub fn  not_empty_test( )  {
        println!("not empty test");
        println!("{{ {} added more chages", "{");
    }

    pub fn test_2() {
        pub fn empty_test() {
            println!("empty test");
        }
        println!("empty test");
        // }
    }

    pub fn returns() -> String {
        String::from("fn empty_test() ")
    }

    pub fn test_in_test() {
        println!("test_in_test");
        pub fn empty_test() {

        }

        pub fn test_in_test_in_test() {
            pub fn empty_test() {

            }
        }
    }
}


pub trait super_trait {
    fn super_trait_method(&self);

    fn empty_test<T: Clone + Send>() ->  String where T: super_trait;
}

impl <'a, t> super_trait for t {
    fn super_trait_method (&self) {
        println!("super trait method");}
/*   dff
gdg
*/
        fn empty_test<T>() ->  String where T: super_trait + Clone {
            String::from("fn empty_test() ");
            fn broken() {
                r#"#"}"#;
            }
            String::from("fn empty_test() ")
        }
    
}


trait Example {
    const CONST_NO_DEFAULT: i32;
    const CONST_WITH_DEFAULT: i32 = 99;
    type TypeNoDefault;
    fn method_without_default(&self);
    fn method_with_default(&self) {}
}

trait Seq<T> {
    fn len(&self) -> u32;
    fn elt_at(&self, n: u32) -> T;
    fn iter<F>(&self, f: F) where F: Fn(T);
}
trait super_trait_2 <T> where T: super_trait {
    fn super_trait_method(&self) {
        println!("super trait method");
    }
}
extern "C" {
    fn abs(input: i32) -> i32;
}

/// function why inner doc comments no worky
pub fn function_within(t: String) -> Result<i32, Box<dyn Error>> {
    //! function within
    pub fn empty_test(t: String) -> Result<i32, Box<dyn Error>> {
        println!("empty test");
        match t.parse::<i32>() {
            Ok(i) => Ok(i),
            Err(e) => Err(e)?,
        
            
        }
    }
    empty_test(t)
}

pub struct Test2<A> 
where 
A: 
super_trait {
    pub contents: String,
    pub history: Vec<A>,
}

impl<A> Test2<A,> 
where A:
super_trait  + Clone,
A: Debug + Clone

{
    pub fn empty_test<'a>() where 'a: Debug {
        println!("empty test");
    }

}

mod c {
    extern "C" {
        pub fn empty_test(t: String);
    }
}


fn main() {
    println!("Hello, world!");
}