terny 0.2.0

A simple, C-like, ternary operator for cleaner syntax.
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

use proc_macro::{Delimiter, Group, Ident, Spacing, Span, TokenStream, TokenTree};

enum ParseState {
	Normal,
	TrueClause,
	FalseClause,
}

/// The only macro exported by the `terny` crate.
/// A simple, C-like, ternary operator for cleaner syntax.
///
/// # Examples
///
/// ```
/// let left = iff!("some text" == "some other text"
///  ? "That's true!"
///  : "Not quite :(");
///
/// let right = if "some text" == "some other text" {
///     "That's true!"
/// } else {
///     "Not quite :("
/// };
///
/// assert_eq!(left, right);
/// ```
#[proc_macro]
pub fn iff(input: TokenStream) -> TokenStream {
	let iter = input.into_iter();
	let iif = Ident::new("if", Span::call_site());

	let mut output: Vec<TokenTree> = vec![];
	let mut true_clause: Vec<TokenTree> = vec![];
	let mut false_clause: Vec<TokenTree> = vec![];
	output.push(TokenTree::Ident(iif));

	let mut state = ParseState::Normal;

	for token in iter {
		if let TokenTree::Punct(ref punc) = token {
			if punc.spacing() == Spacing::Alone {
				match (punc.as_char(), &state) {
					('?', &ParseState::Normal) => {
						state = ParseState::TrueClause;
						continue;
					},
					(':', &ParseState::TrueClause) => {
						state = ParseState::FalseClause;
						continue;
					},
					_ => {},
				}
			}
		}

		match state {
			ParseState::Normal => output.push(token),
			ParseState::TrueClause => true_clause.push(token),
			ParseState::FalseClause => false_clause.push(token),
		}
	}
	let true_group = Group::new(
		Delimiter::Brace,
		TokenStream::from_iter(true_clause.into_iter()),
	);
	let ielse = Ident::new("else", Span::call_site());
	let false_group = Group::new(
		Delimiter::Brace,
		TokenStream::from_iter(false_clause.into_iter()),
	);

	output.push(TokenTree::Group(true_group));
	output.push(TokenTree::Ident(ielse));
	output.push(TokenTree::Group(false_group));

	TokenStream::from_iter(output.into_iter())
}