Rename SkyRawResult and SkyResult

`SkyRawResult` is now `SkyResult` with a generic parameter while
`SkyResult` is now `SkyQueryResult`. This change was done following
naming guidelines and to reduce ambiguity.

Author: ohsayan

CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All changes in this project will be noted in this file.
 
+## Unreleased
+
+### Breaking changes
+
+- `SkyRawResult` is now `SkyResult`
+- `SkyResult` is now `SkyQueryResult`
+
 ## Version 0.6.2
 
 - Added support for pipelined queries

examples/custom-types/src/main.rs

@@ -5,7 +5,7 @@ use skytable::sync::Connection;
 use skytable::types::FromSkyhashBytes;
 use skytable::types::IntoSkyhashBytes;
 use skytable::Element;
-use skytable::SkyRawResult;
+use skytable::SkyResult;
 
 /// Our custom user type
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -34,7 +34,7 @@ impl IntoSkyhashBytes for &User {
 
 // Implement this for our type so that we can directly use it with actions/queries
 impl FromSkyhashBytes for User {
-    fn from_element(e: Element) -> SkyRawResult<Self> {
+    fn from_element(e: Element) -> SkyResult<Self> {
         // we want our JSON as a string
         let my_value_as_string: String = e.try_element_into()?;
         // now let us convert it into our struct

src/actions.rs

@@ -48,7 +48,7 @@ use crate::IntoSkyhashAction;
 use crate::IntoSkyhashBytes;
 use crate::Query;
 use crate::RespCode;
-use crate::SkyRawResult;
+use crate::SkyQueryResult;
 use crate::SkyResult;
 
 cfg_async!(
@@ -62,7 +62,7 @@ cfg_async!(
     /// A raw async connection to the database server
     pub trait AsyncSocket: Send + Sync {
         /// Run the query
-        fn run(&mut self, q: Query) -> AsyncResult<SkyResult>;
+        fn run(&mut self, q: Query) -> AsyncResult<SkyQueryResult>;
     }
     impl<T> AsyncActions for T where T: AsyncSocket {}
 );
@@ -72,7 +72,7 @@ cfg_sync!(
     /// A raw synchronous connection to the database server
     pub trait SyncSocket {
         /// Run the query
-        fn run(&mut self, q: Query) -> SkyResult;
+        fn run(&mut self, q: Query) -> SkyQueryResult;
     }
     impl<T> Actions for T where T: SyncSocket {}
 );
@@ -106,7 +106,7 @@ macro_rules! implement_actions {
             $(
                 $(#[$attr])*
                 #[inline]
-                fn $name<'s, $($($tyargs$(: $ty $(+$tye)*,)* )*)?>(&'s mut self $(, $argname: $argty)*) -> SkyRawResult<$ret> {
+                fn $name<'s, $($($tyargs$(: $ty $(+$tye)*,)* )*)?>(&'s mut self $(, $argname: $argty)*) -> SkyResult<$ret> {
                     gen_match!(self.run($($block)?), $($($mtch)+, $expect),*)
                 }
             )*
@@ -118,7 +118,7 @@ macro_rules! implement_actions {
             $(
                 $(#[$attr])*
                 #[inline]
-                fn $name<'s, $($($tyargs$(: $ty $(+$tye)*,)* )*)?>(&'s mut self $(, $argname: $argty)*) -> AsyncResult<SkyRawResult<$ret>> {
+                fn $name<'s, $($($tyargs$(: $ty $(+$tye)*,)* )*)?>(&'s mut self $(, $argname: $argty)*) -> AsyncResult<SkyResult<$ret>> {
                     Box::pin(async move {gen_match!(self.run($($block)?).await, $($($mtch)+, $expect),*)})
                 }
             )*

src/aio.rs

@@ -31,7 +31,7 @@ use crate::Element;
 use crate::IoResult;
 use crate::Pipeline;
 use crate::Query;
-use crate::SkyRawResult;
+use crate::SkyQueryResult;
 use crate::SkyResult;
 use crate::WriteQueryAsync;
 use bytes::{Buf, BytesMut};
@@ -52,15 +52,15 @@ macro_rules! impl_async_methods {
             ///
             /// ## Panics
             /// This method will panic if the [`Query`] supplied is empty (i.e has no arguments)
-            pub async fn run_simple_query(&mut self, query: &Query) -> SkyResult {
+            pub async fn run_simple_query(&mut self, query: &Query) -> SkyQueryResult {
                 match self._run_query(query).await? {
                     RawResponse::SimpleQuery(sq) => Ok(sq),
                     RawResponse::PipelinedQuery(_) => Err(SkyhashError::InvalidResponse.into()),
                 }
             }
             /// Runs a pipelined query. See the [`Pipeline`](Pipeline) documentation for a guide on
             /// usage
-            pub async fn run_pipeline(&mut self, pipeline: Pipeline) -> SkyRawResult<Vec<Element>> {
+            pub async fn run_pipeline(&mut self, pipeline: Pipeline) -> SkyResult<Vec<Element>> {
                 match self._run_query(&pipeline).await? {
                     RawResponse::PipelinedQuery(pq) => Ok(pq),
                     RawResponse::SimpleQuery(_) => Err(SkyhashError::InvalidResponse.into()),
@@ -69,7 +69,7 @@ macro_rules! impl_async_methods {
             async fn _run_query<Q: WriteQueryAsync<$inner>>(
                 &mut self,
                 query: &Q,
-            ) -> SkyRawResult<RawResponse> {
+            ) -> SkyResult<RawResponse> {
                 query.write_async(&mut self.stream).await?;
                 self.stream.flush().await?;
                 loop {
@@ -110,7 +110,7 @@ macro_rules! impl_async_methods {
             }
         }
         impl crate::actions::AsyncSocket for $ty {
-            fn run(&mut self, q: Query) -> crate::actions::AsyncResult<SkyResult> {
+            fn run(&mut self, q: Query) -> crate::actions::AsyncResult<SkyQueryResult> {
                 Box::pin(async move { self.run_simple_query(&q).await })
             }
         }

src/ddl.rs

@@ -40,7 +40,7 @@ use crate::Element;
 use crate::IntoSkyhashBytes;
 use crate::Query;
 use crate::RespCode;
-use crate::SkyRawResult;
+use crate::SkyResult;
 
 cfg_async! {
     use crate::actions::AsyncResult;
@@ -182,7 +182,7 @@ macro_rules! implement_ddl {
             $(
                 $(#[$attr])*
                 #[inline]
-                fn $name<'s, $($($tyargs: $ty $(+$tye)*, )*)?>(&'s mut self $(, $argname: $argty)*) -> SkyRawResult<$ret> {
+                fn $name<'s, $($($tyargs: $ty $(+$tye)*, )*)?>(&'s mut self $(, $argname: $argty)*) -> SkyResult<$ret> {
                     gen_match!(self.run($($block)?), $($($mtch)+, $expect),*)
                 }
             )*
@@ -195,7 +195,7 @@ macro_rules! implement_ddl {
             $(
                 $(#[$attr])*
                 #[inline]
-                fn $name<'s, $($($tyargs: $ty $(+$tye)*, )*)?>(&'s mut self $(, $argname: $argty)*) -> AsyncResult<SkyRawResult<$ret>> {
+                fn $name<'s, $($($tyargs: $ty $(+$tye)*, )*)?>(&'s mut self $(, $argname: $argty)*) -> AsyncResult<SkyResult<$ret>> {
                     Box::pin(async move {gen_match!(self.run($($block)?).await, $($($mtch)+, $expect),*)})
                 }
             )*

src/deserializer.rs

@@ -31,7 +31,7 @@ use crate::types::Array;
 use crate::types::FlatElement;
 use crate::types::FromSkyhashBytes;
 use crate::RespCode;
-use crate::SkyRawResult;
+use crate::SkyResult;
 use std::hint::unreachable_unchecked;
 
 #[derive(Debug)]
@@ -83,7 +83,7 @@ pub enum Element {
 
 impl Element {
     /// Try to convert an element to a type that implements [`FromSkyhashBytes`]
-    pub fn try_element_into<T: FromSkyhashBytes>(self) -> SkyRawResult<T> {
+    pub fn try_element_into<T: FromSkyhashBytes>(self) -> SkyResult<T> {
         T::from_element(self)
     }
 }

src/lib.rs

@@ -212,9 +212,9 @@ cfg_sync!(
 );
 
 /// A generic result type
-pub type SkyRawResult<T> = Result<T, self::error::Error>;
-/// A specialized error type for queries
-pub type SkyResult = SkyRawResult<Element>;
+pub type SkyResult<T> = Result<T, self::error::Error>;
+/// A result type for queries
+pub type SkyQueryResult = SkyResult<Element>;
 
 #[derive(Debug, Clone)]
 /// A connection builder for easily building connections
@@ -283,7 +283,7 @@ impl ConnectionBuilder {
     }
     cfg_sync! {
         /// Get a [sync connection](sync::Connection) to the database
-        pub fn get_connection(&self) -> SkyRawResult<sync::Connection> {
+        pub fn get_connection(&self) -> SkyResult<sync::Connection> {
             use crate::ddl::Ddl;
             let mut con =
                 sync::Connection::new(self.host.as_ref().unwrap_or(&DEFAULT_HOSTADDR.to_owned()), self.port.unwrap_or(2003))?;
@@ -295,7 +295,7 @@ impl ConnectionBuilder {
             pub fn get_tls_connection(
                 &self,
                 sslcert: String,
-            ) -> SkyRawResult<sync::TlsConnection> {
+            ) -> SkyResult<sync::TlsConnection> {
                 use crate::ddl::Ddl;
                 let mut con = sync::TlsConnection::new(
                     self.host.as_ref().unwrap_or(&DEFAULT_HOSTADDR.to_owned()),
@@ -309,7 +309,7 @@ impl ConnectionBuilder {
     }
     cfg_async! {
         /// Get an [async connection](aio::Connection) to the database
-        pub async fn get_async_connection(&self) -> SkyRawResult<aio::Connection> {
+        pub async fn get_async_connection(&self) -> SkyResult<aio::Connection> {
             use crate::ddl::AsyncDdl;
             let mut con = aio::Connection::new(self.host.as_ref().unwrap_or(&DEFAULT_HOSTADDR.to_owned()), self.port.unwrap_or(2003))
                 .await?;
@@ -321,7 +321,7 @@ impl ConnectionBuilder {
             pub async fn get_async_tls_connection(
                 &self,
                 sslcert: String,
-            ) -> SkyRawResult<aio::TlsConnection> {
+            ) -> SkyResult<aio::TlsConnection> {
                 use crate::ddl::AsyncDdl;
                 let mut con = aio::TlsConnection::new(
                     self.host.as_ref().unwrap_or(&DEFAULT_HOSTADDR.to_owned()),

src/sync.rs

@@ -30,7 +30,7 @@ use crate::Element;
 use crate::IoResult;
 use crate::Pipeline;
 use crate::Query;
-use crate::SkyRawResult;
+use crate::SkyQueryResult;
 use crate::SkyResult;
 use crate::WriteQuerySync;
 use std::io::{Error as IoError, ErrorKind, Read, Write};
@@ -48,7 +48,7 @@ macro_rules! impl_sync_methods {
             /// This method will panic:
             /// - if the [`Query`] supplied is empty (i.e has no arguments)
             /// This function is a subroutine of `run_query` used to parse the response packet
-            pub fn run_simple_query(&mut self, query: &Query) -> SkyResult {
+            pub fn run_simple_query(&mut self, query: &Query) -> SkyQueryResult {
                 assert!(query.len() != 0, "A `Query` cannot be of zero length!");
                 match self._run_query(query)? {
                     RawResponse::SimpleQuery(sq) => Ok(sq),
@@ -57,14 +57,14 @@ macro_rules! impl_sync_methods {
             }
             /// Runs a pipelined query. See the [`Pipeline`](Pipeline) documentation for a guide on
             /// usage
-            pub fn run_pipeline(&mut self, pipeline: Pipeline) -> SkyRawResult<Vec<Element>> {
+            pub fn run_pipeline(&mut self, pipeline: Pipeline) -> SkyResult<Vec<Element>> {
                 assert!(pipeline.len() != 0, "A `Pipeline` cannot be empty!");
                 match self._run_query(&pipeline)? {
                     RawResponse::PipelinedQuery(pq) => Ok(pq),
                     RawResponse::SimpleQuery(_) => Err(SkyhashError::InvalidResponse.into()),
                 }
             }
-            fn _run_query<T: WriteQuerySync>(&mut self, query: &T) -> SkyRawResult<RawResponse> {
+            fn _run_query<T: WriteQuerySync>(&mut self, query: &T) -> SkyResult<RawResponse> {
                 query.write_sync(&mut self.stream)?;
                 self.stream.flush()?;
                 loop {
@@ -109,7 +109,7 @@ macro_rules! impl_sync_methods {
             }
         }
         impl crate::actions::SyncSocket for $ty {
-            fn run(&mut self, q: Query) -> SkyResult {
+            fn run(&mut self, q: Query) -> SkyQueryResult {
                 self.run_simple_query(&q)
             }
         }

src/types.rs

@@ -89,7 +89,7 @@ use crate::error::Error;
 use crate::Element;
 use crate::Query;
 use crate::RespCode;
-use crate::SkyRawResult;
+use crate::SkyResult;
 use core::convert::TryInto;
 use core::ops::Deref;
 use core::ops::DerefMut;
@@ -410,7 +410,7 @@ impl<'a> IntoSkyhashBytes for &'a RawString {
 /// ```no_run
 /// use skytable::types::FromSkyhashBytes;
 /// use skytable::error::Error;
-/// use skytable::{SkyRawResult, Element};
+/// use skytable::{SkyResult, Element};
 ///
 /// pub struct MyCSV {
 ///     name: String,
@@ -420,7 +420,7 @@ impl<'a> IntoSkyhashBytes for &'a RawString {
 ///
 /// // Implement it
 /// impl FromSkyhashBytes for MyCSV {
-///     fn from_element(element: Element) -> SkyRawResult<Self> {
+///     fn from_element(element: Element) -> SkyResult<Self> {
 ///         if let Element::String(st) = element {
 ///             let splits: Vec<&str> = st.split(",").collect();
 ///             Ok(
@@ -449,13 +449,13 @@ impl<'a> IntoSkyhashBytes for &'a RawString {
 ///
 pub trait FromSkyhashBytes: Sized {
     /// Attempt to convert an element to the target type, returning errors if they occur
-    fn from_element(element: Element) -> SkyRawResult<Self>;
+    fn from_element(element: Element) -> SkyResult<Self>;
 }
 
 macro_rules! impl_from_skyhash {
     ($($ty:ty),* $(,)?) => {
         $(impl FromSkyhashBytes for $ty {
-            fn from_element(element: Element) -> SkyRawResult<$ty> {
+            fn from_element(element: Element) -> SkyResult<$ty> {
                 let ret = match element {
                     Element::Binstr(bstr) => String::from_utf8_lossy(&bstr).parse::<$ty>()?,
                     Element::String(st) => st.parse::<$ty>()?,
@@ -471,7 +471,7 @@ macro_rules! impl_from_skyhash {
 impl_from_skyhash!(u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, usize, isize);
 
 impl FromSkyhashBytes for String {
-    fn from_element(element: Element) -> SkyRawResult<String> {
+    fn from_element(element: Element) -> SkyResult<String> {
         let e = match element {
             Element::Binstr(bstr) => std::string::String::from_utf8(bstr)?,
             Element::String(st) => st,
@@ -483,7 +483,7 @@ impl FromSkyhashBytes for String {
 }
 
 impl FromSkyhashBytes for Vec<String> {
-    fn from_element(element: Element) -> SkyRawResult<Self> {
+    fn from_element(element: Element) -> SkyResult<Self> {
         let e = match element {
             Element::Array(Array::Bin(binarr)) => {
                 let mut new_arr = Vec::with_capacity(binarr.len());
@@ -514,7 +514,7 @@ impl FromSkyhashBytes for Vec<String> {
 }
 
 impl FromSkyhashBytes for Vec<Vec<u8>> {
-    fn from_element(e: Element) -> SkyRawResult<Self> {
+    fn from_element(e: Element) -> SkyResult<Self> {
         let e = match e {
             Element::Array(Array::Bin(brr)) => {
                 let mut newarr = Vec::with_capacity(brr.len());
@@ -545,7 +545,7 @@ impl FromSkyhashBytes for Vec<Vec<u8>> {
 }
 
 impl FromSkyhashBytes for Element {
-    fn from_element(e: Element) -> SkyRawResult<Element> {
+    fn from_element(e: Element) -> SkyResult<Element> {
         Ok(e)
     }
 }