malachi 0.9.8

A domain specific pattern matching language made for defining bot commands.
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

// SPDX-License-Identifier: Apache-2.0
// Copyright 2024 Taylan Gökkaya

use super::Match;

impl<'a> Match<'a> {
	/// Returns `Some(vals)` if `self` is `Self::Many`, else returns `None`.
	pub fn many(self) -> Option<Vec<&'a str>> {
		match self {
			Self::Many(v) => Some(v),
			Self::Once(_) => None,
		}
	}

	/// Returns `Some(s)` if `self` is `Self::Once`, else returns `None`.
	pub fn once(self) -> Option<&'a str> {
		match self {
			Self::Once(s) => Some(s),
			Self::Many(_) => None,
		}
	}

	/// Returns a by-reference iterator over this `Match`.
	pub fn iter(&'a self) -> Iter<'a> {
		Iter { m: self, idx: 0 }
	}
}

impl<'a> IntoIterator for Match<'a> {
	type IntoIter = std::vec::IntoIter<&'a str>;
	type Item = &'a str;

	fn into_iter(self) -> Self::IntoIter {
		match self {
			Self::Once(s) => vec![s],
			Self::Many(v) => v,
		}
		.into_iter()
	}
}

/// By-reference iterator over captures of a [Match].
pub struct Iter<'a> {
	m: &'a Match<'a>,
	idx: usize,
}

impl<'a> Iterator for Iter<'a> {
	type Item = &'a str;

	fn next(&mut self) -> Option<&'a str> {
		let o = match self.m {
			Match::Once(s) if self.idx == 0 => Some(*s),
			Match::Many(v) => v.get(self.idx).copied(),
			_ => None,
		};
		self.idx += 1;
		o
	}
}

impl<'a> IntoIterator for &'a Match<'a> {
	type IntoIter = Iter<'a>;
	type Item = &'a str;

	fn into_iter(self) -> Self::IntoIter {
		self.iter()
	}
}