change conversion naming from 'as_' to 'to_'

Author: KodrAus

src/kv/value/fill.rs

@@ -141,7 +141,7 @@ mod tests {
         assert_eq!(
             "a string",
             Value::from_fill(&TestFill)
-                .as_borrowed_str()
+                .to_borrowed_str()
                 .expect("invalid value")
         );
     }

src/kv/value/internal/cast.rs

@@ -15,7 +15,7 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_usize(&self) -> Option<usize> {
+    pub fn to_usize(&self) -> Option<usize> {
         self.inner
             .cast()
             .into_primitive()
@@ -27,7 +27,7 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_u8(&self) -> Option<u8> {
+    pub fn to_u8(&self) -> Option<u8> {
         self.inner
             .cast()
             .into_primitive()
@@ -39,7 +39,7 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_u16(&self) -> Option<u16> {
+    pub fn to_u16(&self) -> Option<u16> {
         self.inner
             .cast()
             .into_primitive()
@@ -51,7 +51,7 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_u32(&self) -> Option<u32> {
+    pub fn to_u32(&self) -> Option<u32> {
         self.inner
             .cast()
             .into_primitive()
@@ -63,15 +63,15 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_u64(&self) -> Option<u64> {
+    pub fn to_u64(&self) -> Option<u64> {
         self.inner.cast().into_primitive().into_u64()
     }
 
     /// Try get a `isize` from this value.
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_isize(&self) -> Option<isize> {
+    pub fn to_isize(&self) -> Option<isize> {
         self.inner
             .cast()
             .into_primitive()
@@ -83,7 +83,7 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_i8(&self) -> Option<i8> {
+    pub fn to_i8(&self) -> Option<i8> {
         self.inner
             .cast()
             .into_primitive()
@@ -95,7 +95,7 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_i16(&self) -> Option<i16> {
+    pub fn to_i16(&self) -> Option<i16> {
         self.inner
             .cast()
             .into_primitive()
@@ -107,7 +107,7 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_i32(&self) -> Option<i32> {
+    pub fn to_i32(&self) -> Option<i32> {
         self.inner
             .cast()
             .into_primitive()
@@ -119,15 +119,15 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_i64(&self) -> Option<i64> {
+    pub fn to_i64(&self) -> Option<i64> {
         self.inner.cast().into_primitive().into_i64()
     }
 
     /// Try get a `f32` from this value.
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_f32(&self) -> Option<f32> {
+    pub fn to_f32(&self) -> Option<f32> {
         self.inner
             .cast()
             .into_primitive()
@@ -139,31 +139,31 @@ impl<'v> Value<'v> {
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_f64(&self) -> Option<f64> {
+    pub fn to_f64(&self) -> Option<f64> {
         self.inner.cast().into_primitive().into_f64()
     }
 
     /// Try get a `bool` from this value.
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_bool(&self) -> Option<bool> {
+    pub fn to_bool(&self) -> Option<bool> {
         self.inner.cast().into_primitive().into_bool()
     }
 
     /// Try get a `char` from this value.
     ///
     /// This method is cheap for primitive types, but may call arbitrary
     /// serialization implementations for complex ones.
-    pub fn as_char(&self) -> Option<char> {
+    pub fn to_char(&self) -> Option<char> {
         self.inner.cast().into_primitive().into_char()
     }
 
     /// Try get a `str` from this value.
     ///
     /// This method is cheap for primitive types. It won't allocate an owned
     /// `String` if the value is a complex type.
-    pub fn as_borrowed_str(&self) -> Option<&str> {
+    pub fn to_borrowed_str(&self) -> Option<&str> {
         self.inner.cast().into_primitive().into_borrowed_str()
     }
 }
@@ -384,7 +384,7 @@ mod std_support {
         /// This method is cheap for primitive types, but may call arbitrary
         /// serialization implementations for complex ones. If the serialization
         /// implementation produces a short lived string it will be allocated.
-        pub fn as_str(&self) -> Option<Cow<str>> {
+        pub fn to_str(&self) -> Option<Cow<str>> {
             self.inner.cast().into_str()
         }
     }
@@ -410,19 +410,19 @@ mod std_support {
                 "a string"
                     .to_owned()
                     .to_value()
-                    .as_borrowed_str()
+                    .to_borrowed_str()
                     .expect("invalid value")
             );
             assert_eq!(
                 "a string",
-                &*"a string".to_value().as_str().expect("invalid value")
+                &*"a string".to_value().to_str().expect("invalid value")
             );
             assert_eq!(
                 "a string",
                 &*"a string"
                     .to_owned()
                     .to_value()
-                    .as_str()
+                    .to_str()
                     .expect("invalid value")
             );
         }
@@ -439,37 +439,37 @@ mod tests {
             "a string",
             "a string"
                 .to_value()
-                .as_borrowed_str()
+                .to_borrowed_str()
                 .expect("invalid value")
         );
         assert_eq!(
             "a string",
             Some("a string")
                 .to_value()
-                .as_borrowed_str()
+                .to_borrowed_str()
                 .expect("invalid value")
         );
 
-        assert_eq!(1u8, 1u64.to_value().as_u8().expect("invalid value"));
-        assert_eq!(1u16, 1u64.to_value().as_u16().expect("invalid value"));
-        assert_eq!(1u32, 1u64.to_value().as_u32().expect("invalid value"));
-        assert_eq!(1u64, 1u64.to_value().as_u64().expect("invalid value"));
-        assert_eq!(1usize, 1u64.to_value().as_usize().expect("invalid value"));
+        assert_eq!(1u8, 1u64.to_value().to_u8().expect("invalid value"));
+        assert_eq!(1u16, 1u64.to_value().to_u16().expect("invalid value"));
+        assert_eq!(1u32, 1u64.to_value().to_u32().expect("invalid value"));
+        assert_eq!(1u64, 1u64.to_value().to_u64().expect("invalid value"));
+        assert_eq!(1usize, 1u64.to_value().to_usize().expect("invalid value"));
 
-        assert_eq!(-1i8, -1i64.to_value().as_i8().expect("invalid value"));
-        assert_eq!(-1i16, -1i64.to_value().as_i16().expect("invalid value"));
-        assert_eq!(-1i32, -1i64.to_value().as_i32().expect("invalid value"));
-        assert_eq!(-1i64, -1i64.to_value().as_i64().expect("invalid value"));
-        assert_eq!(-1isize, -1i64.to_value().as_isize().expect("invalid value"));
+        assert_eq!(-1i8, -1i64.to_value().to_i8().expect("invalid value"));
+        assert_eq!(-1i16, -1i64.to_value().to_i16().expect("invalid value"));
+        assert_eq!(-1i32, -1i64.to_value().to_i32().expect("invalid value"));
+        assert_eq!(-1i64, -1i64.to_value().to_i64().expect("invalid value"));
+        assert_eq!(-1isize, -1i64.to_value().to_isize().expect("invalid value"));
 
-        assert!(1f32.to_value().as_f32().is_some(), "invalid value");
-        assert!(1f64.to_value().as_f64().is_some(), "invalid value");
+        assert!(1f32.to_value().to_f32().is_some(), "invalid value");
+        assert!(1f64.to_value().to_f64().is_some(), "invalid value");
 
-        assert_eq!(1u32, 1i64.to_value().as_u32().expect("invalid value"));
-        assert_eq!(1i32, 1u64.to_value().as_i32().expect("invalid value"));
-        assert!(1f32.to_value().as_i32().is_some(), "invalid value");
+        assert_eq!(1u32, 1i64.to_value().to_u32().expect("invalid value"));
+        assert_eq!(1i32, 1u64.to_value().to_i32().expect("invalid value"));
+        assert!(1f32.to_value().to_i32().is_some(), "invalid value");
 
-        assert_eq!('a', 'a'.to_value().as_char().expect("invalid value"));
-        assert_eq!(true, true.to_value().as_bool().expect("invalid value"));
+        assert_eq!('a', 'a'.to_value().to_char().expect("invalid value"));
+        assert_eq!(true, true.to_value().to_bool().expect("invalid value"));
     }
 }

src/kv/value/internal/fmt.rs

@@ -131,14 +131,14 @@ mod tests {
         assert_eq!(
             42u32,
             kv::Value::from_debug(&42u64)
-                .as_u32()
+                .to_u32()
                 .expect("invalid value")
         );
 
         assert_eq!(
             "a string",
             kv::Value::from_display(&"a string")
-                .as_borrowed_str()
+                .to_borrowed_str()
                 .expect("invalid value")
         );
     }

src/kv/value/internal/sval.rs

@@ -172,22 +172,22 @@ mod tests {
         assert_eq!(
             42u32,
             kv::Value::from_sval(&42u64)
-                .as_u32()
+                .to_u32()
                 .expect("invalid value")
         );
 
         assert_eq!(
             "a string",
             kv::Value::from_sval(&"a string")
-                .as_borrowed_str()
+                .to_borrowed_str()
                 .expect("invalid value")
         );
 
         #[cfg(feature = "std")]
         assert_eq!(
             "a string",
             kv::Value::from_sval(&"a string")
-                .as_str()
+                .to_str()
                 .expect("invalid value")
         );
     }

src/lib.rs

@@ -1663,7 +1663,7 @@ mod tests {
                 .key_values()
                 .get("b".into())
                 .expect("missing key")
-                .as_borrowed_str()
+                .to_borrowed_str()
                 .expect("invalid value")
         );
     }