hecks 3.14.0 → 4.0.0

data/rust/src/kernel/vocab/field_hint.rs

@@ -13,48 +13,42 @@ pub enum FieldHint {
 
 impl FieldHint {
     /// Every row, in declared order.
-    pub const ALL: &'static [FieldHint] = &[
-        FieldHint::Email,
-        FieldHint::Url,
-        FieldHint::Tel,
-        FieldHint::Textarea,
-    ];
+    pub const ALL: &'static [Self] = &[Self::Email, Self::Url, Self::Tel, Self::Textarea];
 
     /// The row's declared `name`.
-    pub fn name(&self) -> &'static str {
+    pub const fn name(&self) -> &'static str {
         match self {
-            FieldHint::Email => "email",
-            FieldHint::Url => "url",
-            FieldHint::Tel => "tel",
-            FieldHint::Textarea => "textarea",
+            Self::Email => "email",
+            Self::Url => "url",
+            Self::Tel => "tel",
+            Self::Textarea => "textarea",
         }
     }
 
     /// The row's declared `pattern`.
-    pub fn pattern(&self) -> &'static str {
+    pub const fn pattern(&self) -> &'static str {
         match self {
-            FieldHint::Email => "email",
-            FieldHint::Url => "\\b(url|uri|website|link)\\b",
-            FieldHint::Tel => "phone|\\btel(ephone)?\\b",
-            FieldHint::Textarea => "\\b(text|body|note|notes|description|message|comment)\\b",
+            Self::Email => "email",
+            Self::Url => "\\b(url|uri|website|link)\\b",
+            Self::Tel => "phone|\\btel(ephone)?\\b",
+            Self::Textarea => "\\b(text|body|note|notes|description|message|comment)\\b",
         }
     }
 
     /// The row's declared `resolves_to`.
-    pub fn resolves_to(&self) -> &'static str {
+    pub const fn resolves_to(&self) -> &'static str {
         match self {
-            FieldHint::Email => "html_type",
-            FieldHint::Url => "html_type",
-            FieldHint::Tel => "html_type",
-            FieldHint::Textarea => "kind",
+            Self::Email => "html_type",
+            Self::Url => "html_type",
+            Self::Tel => "html_type",
+            Self::Textarea => "kind",
         }
     }
 
     /// The row whose `name` is `name`, if any.
-    pub fn from_name(name: &str) -> Option<FieldHint> {
-        FieldHint::ALL.iter().copied().find(|row| row.name() == name)
+    pub fn from_name(name: &str) -> Option<Self> {
+        Self::ALL.iter().copied().find(|row| row.name() == name)
     }
-
 }
 
 #[cfg(test)]
@@ -63,7 +57,7 @@ mod tests {
 
     #[test]
     fn every_row_is_found_by_its_own_name() {
-        for row in FieldHint::ALL.iter() {
+        for row in FieldHint::ALL {
             assert_eq!(FieldHint::from_name(row.name()), Some(*row));
         }
     }

data/rust/src/kernel/vocab/mod.rs

@@ -7,14 +7,14 @@
 // exhaustively by its own accessors — no wildcard arm — so a row the
 // language gains fails to compile until it is handled.
 
-pub mod refusal_template;
-pub mod query_comparator;
-pub mod field_hint;
 pub mod aggregate_dispatch_order;
 pub mod entity_dispatch_order;
+pub mod field_hint;
+pub mod query_comparator;
+pub mod refusal_template;
 
-pub use refusal_template::RefusalSite;
-pub use query_comparator::QueryComparator;
-pub use field_hint::FieldHint;
 pub use aggregate_dispatch_order::AggregateStep;
 pub use entity_dispatch_order::EntityStep;
+pub use field_hint::FieldHint;
+pub use query_comparator::QueryComparator;
+pub use refusal_template::RefusalSite;

data/rust/src/kernel/vocab/query_comparator.rs

@@ -18,38 +18,37 @@ pub enum QueryComparator {
 
 impl QueryComparator {
     /// Every row, in declared order.
-    pub const ALL: &'static [QueryComparator] = &[
-        QueryComparator::Eq,
-        QueryComparator::Ne,
-        QueryComparator::Gt,
-        QueryComparator::Gte,
-        QueryComparator::Lt,
-        QueryComparator::Lte,
-        QueryComparator::In,
-        QueryComparator::Contains,
-        QueryComparator::NoneInState,
+    pub const ALL: &'static [Self] = &[
+        Self::Eq,
+        Self::Ne,
+        Self::Gt,
+        Self::Gte,
+        Self::Lt,
+        Self::Lte,
+        Self::In,
+        Self::Contains,
+        Self::NoneInState,
     ];
 
     /// The row's declared `name`.
-    pub fn name(&self) -> &'static str {
+    pub const fn name(&self) -> &'static str {
         match self {
-            QueryComparator::Eq => "eq",
-            QueryComparator::Ne => "ne",
-            QueryComparator::Gt => "gt",
-            QueryComparator::Gte => "gte",
-            QueryComparator::Lt => "lt",
-            QueryComparator::Lte => "lte",
-            QueryComparator::In => "in",
-            QueryComparator::Contains => "contains",
-            QueryComparator::NoneInState => "none_in_state",
+            Self::Eq => "eq",
+            Self::Ne => "ne",
+            Self::Gt => "gt",
+            Self::Gte => "gte",
+            Self::Lt => "lt",
+            Self::Lte => "lte",
+            Self::In => "in",
+            Self::Contains => "contains",
+            Self::NoneInState => "none_in_state",
         }
     }
 
     /// The row whose `name` is `name`, if any.
-    pub fn from_name(name: &str) -> Option<QueryComparator> {
-        QueryComparator::ALL.iter().copied().find(|row| row.name() == name)
+    pub fn from_name(name: &str) -> Option<Self> {
+        Self::ALL.iter().copied().find(|row| row.name() == name)
     }
-
 }
 
 #[cfg(test)]
@@ -58,7 +57,7 @@ mod tests {
 
     #[test]
     fn every_row_is_found_by_its_own_name() {
-        for row in QueryComparator::ALL.iter() {
+        for row in QueryComparator::ALL {
             assert_eq!(QueryComparator::from_name(row.name()), Some(*row));
         }
     }