tear 0.5.1

Typed early returns and loop control + Syntax sugar for try!-like error handling
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
105
106
107
108
109
110
111
112
113
114
115
116

// We test the simple twist!

use tear::twist;
use tear::{next, last, resume};
use tear::Looping;

// All compile fail errors go here
#[cfg(not(any(feature = "experimental", feature = "ignore-ui")))] // Feature flags to ignore test
#[test] fn bad_input () {
	use trybuild;
	let t = trybuild::TestCases::new();
	t.compile_fail("tests/twist/*.rs");
}

#[test] fn simple_break() {
	loop {
		twist! { last!() }
		panic!("Should have broken");
	}
}

#[test] fn simple_continue() {
	let mut i = 0;
	loop {
		i += 1;
		if i > 4 {
			break;
		}

		twist! { next!() }
		panic!("Should be skipped over");
	}
	assert_eq![ i, 5 ]
}

#[test] fn simple_resume() {
	let mut i = 0;
	loop {
		i = twist! { resume!(6) };
		break;
	}
	assert_eq![ i, 6 ];
}

#[test] fn simple_breakval() {
	let x = loop {
		twist! { -val Looping::BreakVal { label: None, value: 5 } }
		panic!("Should have broken");
	};
	assert_eq![ x, 5 ];
}

#[test] fn labeled_break() {
	'a: loop {
		loop {
			twist! { -with 'a | last!() }
			panic!("Should have broken");
		}
	}
}

#[test] fn labeled_continue() {
	let mut i = 0;
	'a: loop {
		i += 1;
		loop {
			if i > 2 {
				break 'a;
			}

			twist! { -with 'a | next!() }
			panic!("Should have broken");
		}
	}
	assert_eq![ i, 3 ];
}

#[test] fn labeled_resume() {
	let mut i = 0;
	'a: loop {
		loop {
			i = twist! { -with 'a | resume!(9) };
			break;
		}
		break;
	}
	assert_eq![ i, 9 ];
}

#[test] fn labeled_breakval() {
	let x = 'a: loop {
		loop {
			twist! { -val -with 'a | Looping::BreakVal { label: None, value: 5 } }
		}
	};
	assert_eq![ x, 5 ];
}

/* I'm too lazy to test all possibilities, so we test 2 of them with the mapping syntax */

#[test] fn map_breakval () {
	let x = loop {
		let _ = twist! { -val Err::<i32, _>("failed") => |_| Looping::BreakVal { label: None, value: 8 } };
		break 3;
	};
	assert_eq![ x, 8 ];
}

#[test] fn map_break_labeled () {
	let mut v = 0;
	'a: loop {
		v = twist! { -with 'a | Some(3) => |_| last!() };
		break;
	}
	assert_eq![ v, 3 ];
}