decurse 0.0.4

Macro to make recursive function run on the heap (i.e. no stack overflow).
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

use std::{cell::RefCell, rc::Rc};

use decurse::decurse;

#[test]
fn test_factorial() {
	#[decurse]
	fn factorial(x: u32) -> u32 {
		if x == 0 {
			1
		} else {
			x * factorial(x - 1)
		}
	}
	assert_eq!(factorial(6), 720);
}

#[test]
fn test_fibonacci() {
	#[decurse]
	fn fibonacci(x: u32) -> u32 {
		if x == 0 || x == 1 {
			1
		} else {
			fibonacci(x - 1) + fibonacci(x - 2)
		}
	}
	assert_eq!(fibonacci(10), 89);
}

#[test]
fn test_no_return() {
	#[decurse]
	fn no_return(modify_me: Rc<RefCell<String>>, iter: u32) {
		if iter == 0 {
		} else {
			modify_me.borrow_mut().push_str(&format!("{}, ", iter));
			no_return(modify_me, iter - 1);
		}
	}
	let cell = RefCell::new(String::new());
	let rc = Rc::new(cell);
	no_return(rc.clone(), 5);
	assert_eq!(*(rc.borrow()), "5, 4, 3, 2, 1, ");
}

#[test]
fn test_no_arg() {
	thread_local! {
		static CHANGE_ME: RefCell<usize> = RefCell::new(0);
	};

	#[decurse]
	fn no_arg() {
		if CHANGE_ME.with(|f: &RefCell<usize>| {
			let mut bm = f.borrow_mut();
			if *bm == 5 {
				false
			} else {
				*bm += 1;
				true
			}
		}) {
			no_arg();
		}
	}

	CHANGE_ME.with(|f| {
		*f.borrow_mut() = 0;
	});
	no_arg();
	CHANGE_ME.with(|f| {
		assert_eq!(*f.borrow(), 5);
	});
}

#[test]
fn test_generic() {
	#[decurse]
	fn recursive<T: std::ops::Sub<i32, Output = T> + std::cmp::PartialEq + 'static>(
		value: T,
		until: T,
	) -> T {
		if value == until {
			value
		} else {
			recursive::<T>(value - 1, until)
		}
	}
	assert_eq!(recursive(5, 0), 0);
}