locspan 0.8.2

Code mapping utility types and traits.
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

use super::Stripped;
use crate::Meta;
use std::collections::HashMap;
use std::hash::Hash;

/// Defines the equality of values
/// without considering the metadata.
///
/// ## Example
///
/// ```
/// use locspan::{Loc, Span, Location, StrippedPartialEq, BorrowStripped};
///
/// #[derive(PartialEq, Eq, Debug)]
/// struct MyValue(u32);
///
/// impl StrippedPartialEq for MyValue {
///   fn stripped_eq(&self, other: &Self) -> bool {
///     self == other
///   }
/// }
///
/// let a = Loc(MyValue(0), Location::new("a", Span::new(0, 1)));
/// let b = Loc(MyValue(0), Location::new("b", Span::new(2, 4)));
///
/// // `a` and `b` are not equals,
/// // because their associated `Location`s are different.
/// assert_ne!(a, b);
///
/// // However using `BorrowStripped::stripped` we can
/// // compare the inner values regardless of the locations.
/// assert_eq!(a.stripped(), b.stripped());
/// ```
pub trait StrippedPartialEq<U: ?Sized = Self> {
	fn stripped_eq(&self, other: &U) -> bool;
}

impl<T: StrippedPartialEq<U>, U> PartialEq<Stripped<U>> for Stripped<T> {
	fn eq(&self, other: &Stripped<U>) -> bool {
		self.0.stripped_eq(&other.0)
	}
}

impl<T: StrippedPartialEq<U>, U> StrippedPartialEq<Stripped<U>> for Stripped<T> {
	fn stripped_eq(&self, other: &Stripped<U>) -> bool {
		self.0.stripped_eq(&other.0)
	}
}

impl<'u, 't, U, T: StrippedPartialEq<U>> StrippedPartialEq<&'u U> for &'t T {
	fn stripped_eq(&self, other: &&'u U) -> bool {
		T::stripped_eq(*self, *other)
	}
}

impl<U, N, T: StrippedPartialEq<U>, M> StrippedPartialEq<Meta<U, N>> for Meta<T, M> {
	fn stripped_eq(&self, other: &Meta<U, N>) -> bool {
		self.value().stripped_eq(other.value())
	}
}

impl<T: StrippedPartialEq<U>, U> StrippedPartialEq<Box<U>> for Box<T> {
	fn stripped_eq(&self, other: &Box<U>) -> bool {
		(**self).stripped_eq(&**other)
	}
}

impl<T: StrippedPartialEq<U>, U> StrippedPartialEq<Option<U>> for Option<T> {
	fn stripped_eq(&self, other: &Option<U>) -> bool {
		match (self, other) {
			(Some(a), Some(b)) => a.stripped_eq(b),
			(None, None) => true,
			_ => false,
		}
	}
}

impl<T: StrippedPartialEq<U>, U> StrippedPartialEq<Vec<U>> for Vec<T> {
	fn stripped_eq(&self, other: &Vec<U>) -> bool {
		self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a.stripped_eq(b))
	}
}

impl<K: Eq + Hash, V: StrippedPartialEq<W>, W> StrippedPartialEq<HashMap<K, W>> for HashMap<K, V> {
	fn stripped_eq(&self, other: &HashMap<K, W>) -> bool {
		self.len() == other.len()
			&& self
				.iter()
				.all(|(key, value)| other.get(key).map_or(false, |v| value.stripped_eq(v)))
	}
}

#[cfg(feature = "hashbrown")]
impl<K: Eq + Hash, V: StrippedPartialEq<W>, W> StrippedPartialEq<hashbrown::HashMap<K, W>>
	for hashbrown::HashMap<K, V>
{
	fn stripped_eq(&self, other: &hashbrown::HashMap<K, W>) -> bool {
		self.len() == other.len()
			&& self
				.iter()
				.all(|(key, value)| other.get(key).map_or(false, |v| value.stripped_eq(v)))
	}
}

#[cfg(feature = "indexmap")]
impl<K: Eq + Hash, V: StrippedPartialEq<W>, W> StrippedPartialEq<indexmap::IndexMap<K, W>>
	for indexmap::IndexMap<K, V>
{
	fn stripped_eq(&self, other: &indexmap::IndexMap<K, W>) -> bool {
		self.len() == other.len()
			&& self
				.iter()
				.all(|(key, value)| other.get(key).map_or(false, |v| value.stripped_eq(v)))
	}
}