rune/runtime/
range_to_inclusive.rs

Help
1use core::cmp::Ordering;
2use core::fmt;
3use core::ops;
4
5use crate as rune;
6use crate::alloc::clone::TryClone;
7use crate::runtime::{
8    EnvProtocolCaller, FromValue, ProtocolCaller, RuntimeError, ToValue, Value, VmResult,
9};
10use crate::Any;
11
12/// Type for an inclusive range expression `..=end`.
13///
14/// # Examples
15///
16/// ```rune
17/// let range = ..=10;
18/// assert!(range.contains(-10));
19/// assert!(range.contains(5));
20/// assert!(range.contains(10));
21/// assert!(!range.contains(20));
22///
23/// assert!(range is std::ops::RangeToInclusive);
24/// ```
25///
26/// Ranges can contain any type:
27///
28/// ```rune
29/// let range = ..='f';
30/// assert_eq!(range.end, 'f');
31/// range.end = 'g';
32/// assert_eq!(range.end, 'g');
33/// ```
34///
35/// # Examples
36///
37/// ```rust
38/// use rune::runtime::RangeToInclusive;
39///
40/// let end = rune::to_value(10)?;
41/// let _ = RangeToInclusive::new(end);
42/// # Ok::<_, rune::support::Error>(())
43/// ```
44#[derive(Any, Clone, TryClone)]
45#[rune(constructor, item = ::std::ops)]
46pub struct RangeToInclusive {
47    /// The end value of the range.
48    #[rune(get, set)]
49    pub end: Value,
50}
51
52impl RangeToInclusive {
53    /// Construct a new range.
54    pub fn new(end: Value) -> Self {
55        Self { end }
56    }
57
58    /// Test the range for partial equality.
59    ///
60    /// # Examples
61    ///
62    /// ```rune
63    /// let range = ..='e';
64    /// assert!(range == (..='e'));
65    /// assert!(range != (..='f'));
66    ///
67    /// let range = ..=2.0;
68    /// assert!(range == (..=2.0));
69    /// assert!(range != (..=f64::NAN));
70    /// assert!((..=f64::NAN) != (..=f64::NAN));
71    /// ```
72    #[rune::function(keep, protocol = PARTIAL_EQ)]
73    pub fn partial_eq(&self, other: &Self) -> VmResult<bool> {
74        self.partial_eq_with(other, &mut EnvProtocolCaller)
75    }
76
77    pub(crate) fn partial_eq_with(
78        &self,
79        b: &Self,
80        caller: &mut dyn ProtocolCaller,
81    ) -> VmResult<bool> {
82        Value::partial_eq_with(&self.end, &b.end, caller)
83    }
84
85    /// Test the range for total equality.
86    ///
87    /// # Examples
88    ///
89    /// ```rune
90    /// use std::ops::eq;
91    ///
92    /// let range = ..='e';
93    /// assert!(eq(range, ..='e'));
94    /// assert!(!eq(range, ..='f'));
95    /// ```
96    #[rune::function(keep, protocol = EQ)]
97    pub fn eq(&self, other: &Self) -> VmResult<bool> {
98        self.eq_with(other, &mut EnvProtocolCaller)
99    }
100
101    pub(crate) fn eq_with(&self, b: &Self, caller: &mut dyn ProtocolCaller) -> VmResult<bool> {
102        Value::eq_with(&self.end, &b.end, caller)
103    }
104
105    /// Test the range for partial ordering.
106    ///
107    /// # Examples
108    ///
109    /// ```rune
110    /// assert!((..='a') < (..='b'));
111    /// assert!((..='d') > (..='b'));
112    /// assert!(!((..=f64::NAN) > (..=f64::INFINITY)));
113    /// assert!(!((..=f64::NAN) < (..=f64::INFINITY)));
114    /// ```
115    #[rune::function(keep, protocol = PARTIAL_CMP)]
116    pub fn partial_cmp(&self, other: &Self) -> VmResult<Option<Ordering>> {
117        self.partial_cmp_with(other, &mut EnvProtocolCaller)
118    }
119
120    pub(crate) fn partial_cmp_with(
121        &self,
122        b: &Self,
123        caller: &mut dyn ProtocolCaller,
124    ) -> VmResult<Option<Ordering>> {
125        Value::partial_cmp_with(&self.end, &b.end, caller)
126    }
127
128    /// Test the range for total ordering.
129    ///
130    /// # Examples
131    ///
132    /// ```rune
133    /// use std::ops::cmp;
134    /// use std::cmp::Ordering;
135    ///
136    /// assert_eq!(cmp(..='a', ..='b'), Ordering::Less);
137    /// assert_eq!(cmp(..='c', ..='b'), Ordering::Greater);
138    /// ```
139    #[rune::function(keep, protocol = CMP)]
140    pub fn cmp(&self, other: &Self) -> VmResult<Ordering> {
141        self.cmp_with(other, &mut EnvProtocolCaller)
142    }
143
144    pub(crate) fn cmp_with(&self, b: &Self, caller: &mut dyn ProtocolCaller) -> VmResult<Ordering> {
145        Value::cmp_with(&self.end, &b.end, caller)
146    }
147
148    /// Test if the range contains the given value.
149    ///
150    /// The check is performed using the [`PARTIAL_CMP`] protocol.
151    ///
152    /// # Examples
153    ///
154    /// ```rune
155    /// let range = ..=10;
156    ///
157    /// assert!(range.contains(-10));
158    /// assert!(range.contains(5));
159    /// assert!(range.contains(10));
160    /// assert!(!range.contains(20));
161    ///
162    /// assert!(range is std::ops::RangeToInclusive);
163    /// ```
164    #[rune::function(keep)]
165    pub(crate) fn contains(&self, value: Value) -> VmResult<bool> {
166        self.contains_with(value, &mut EnvProtocolCaller)
167    }
168
169    pub(crate) fn contains_with(
170        &self,
171        value: Value,
172        caller: &mut dyn ProtocolCaller,
173    ) -> VmResult<bool> {
174        VmResult::Ok(matches!(
175            vm_try!(Value::partial_cmp_with(&self.end, &value, caller)),
176            Some(Ordering::Greater | Ordering::Equal)
177        ))
178    }
179}
180
181impl fmt::Debug for RangeToInclusive {
182    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
183        write!(f, "..={:?}", self.end)
184    }
185}
186
187impl<Idx> ToValue for ops::RangeToInclusive<Idx>
188where
189    Idx: ToValue,
190{
191    fn to_value(self) -> Result<Value, RuntimeError> {
192        let end = self.end.to_value()?;
193        Ok(Value::new(RangeToInclusive::new(end))?)
194    }
195}
196
197impl<Idx> FromValue for ops::RangeToInclusive<Idx>
198where
199    Idx: FromValue,
200{
201    #[inline]
202    fn from_value(value: Value) -> Result<Self, RuntimeError> {
203        let range = value.downcast::<RangeToInclusive>()?;
204        let end = Idx::from_value(range.end)?;
205        Ok(ops::RangeToInclusive { end })
206    }
207}
rune/runtime/range_to_inclusive.rs

rune/runtime/
range_to_inclusive.rs
