Make Result alias more flexible

Author: jplatte

crates/matrix-sdk-appservice/src/webserver/warp.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{net::ToSocketAddrs, result::Result as StdResult};
+use std::net::ToSocketAddrs;
 
 use matrix_sdk::{
     bytes::Bytes,
@@ -168,7 +168,7 @@ mod handlers {
         _user_id: String,
         appservice: AppService,
         request: http::Request<Bytes>,
-    ) -> StdResult<impl warp::Reply, Rejection> {
+    ) -> Result<impl warp::Reply, Rejection> {
         if let Some(user_exists) = appservice.event_handler.users.lock().await.as_mut() {
             let request =
                 query_user::IncomingRequest::try_from_http_request(request).map_err(Error::from)?;
@@ -185,7 +185,7 @@ mod handlers {
         _room_id: String,
         appservice: AppService,
         request: http::Request<Bytes>,
-    ) -> StdResult<impl warp::Reply, Rejection> {
+    ) -> Result<impl warp::Reply, Rejection> {
         if let Some(room_exists) = appservice.event_handler.rooms.lock().await.as_mut() {
             let request =
                 query_room::IncomingRequest::try_from_http_request(request).map_err(Error::from)?;
@@ -202,7 +202,7 @@ mod handlers {
         _txn_id: String,
         appservice: AppService,
         request: http::Request<Bytes>,
-    ) -> StdResult<impl warp::Reply, Rejection> {
+    ) -> Result<impl warp::Reply, Rejection> {
         let incoming_transaction: ruma::api::appservice::event::push_events::v1::IncomingRequest =
             ruma::api::IncomingRequest::try_from_http_request(request).map_err(Error::from)?;
 
@@ -224,7 +224,7 @@ struct ErrorMessage {
     message: String,
 }
 
-pub async fn handle_rejection(err: Rejection) -> std::result::Result<impl Reply, Rejection> {
+pub async fn handle_rejection(err: Rejection) -> Result<impl Reply, Rejection> {
     if err.find::<Unauthorized>().is_some() || err.find::<warp::reject::InvalidQuery>().is_some() {
         let code = http::StatusCode::UNAUTHORIZED;
         let message = "UNAUTHORIZED";

crates/matrix-sdk/src/client.rs

@@ -230,7 +230,7 @@ impl Client {
     ///
     /// // Finally let's try to login.
     /// client.login(alice, "password", None, None).await?;
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     ///
     /// [spec]: https://spec.matrix.org/unstable/client-server-api/#well-known-uri
@@ -866,7 +866,7 @@ impl Client {
     ///     "Logged in as {}, got device_id {} and access_token {}",
     ///     user, response.device_id, response.access_token
     /// );
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     ///
     /// [`restore_login`]: #method.restore_login
@@ -1528,7 +1528,7 @@ impl Client {
     /// for room in response.chunk {
     ///     println!("Found room {:?}", room);
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn public_rooms_filtered(
         &self,
@@ -1628,7 +1628,7 @@ impl Client {
     ///
     /// // Check the corresponding Response struct to find out what types are
     /// // returned
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn send<Request>(
         &self,
@@ -1663,7 +1663,7 @@ impl Client {
     ///         device.display_name.as_deref().unwrap_or("")
     ///     );
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn devices(&self) -> HttpResult<get_devices::Response> {
         let request = get_devices::Request::new();
@@ -1716,7 +1716,7 @@ impl Client {
     ///             .await?;
     ///     }
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     pub async fn delete_devices(
         &self,
         devices: &[DeviceIdBox],
@@ -1805,7 +1805,7 @@ impl Client {
     /// // Now keep on syncing forever. `sync()` will use the stored sync token
     /// // from our `sync_once()` call automatically.
     /// client.sync(SyncSettings::default()).await;
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     ///
     /// [`sync`]: #method.sync
@@ -1896,7 +1896,7 @@ impl Client {
     /// // Now keep on syncing forever. `sync()` will use the latest sync token
     /// // automatically.
     /// client.sync(SyncSettings::default()).await;
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     ///
     /// [argument docs]: #method.sync_once
@@ -2025,7 +2025,7 @@ impl Client {
     ///     }
     /// }
     ///
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     #[instrument]
     pub async fn sync_stream<'a>(

crates/matrix-sdk/src/config/client.rs

@@ -89,7 +89,7 @@ impl ClientConfig {
     /// let client_config = ClientConfig::new()
     ///     .proxy("http://localhost:8080")?;
     ///
-    /// # matrix_sdk::Result::Ok(())
+    /// # Result::<_, matrix_sdk::Error>::Ok(())
     /// ```
     #[cfg(not(target_arch = "wasm32"))]
     pub fn proxy(mut self, proxy: &str) -> Result<Self> {
@@ -104,7 +104,7 @@ impl ClientConfig {
     }
 
     /// Set a custom HTTP user agent for the client.
-    pub fn user_agent(mut self, user_agent: &str) -> std::result::Result<Self, InvalidHeaderValue> {
+    pub fn user_agent(mut self, user_agent: &str) -> Result<Self, InvalidHeaderValue> {
         self.user_agent = Some(HeaderValue::from_str(user_agent)?);
         Ok(self)
     }

crates/matrix-sdk/src/encryption/identities/devices.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{ops::Deref, result::Result as StdResult};
+use std::ops::Deref;
 
 use matrix_sdk_base::crypto::{
     store::CryptoStoreError, Device as BaseDevice, LocalTrust, ReadOnlyDevice,
@@ -250,7 +250,7 @@ impl Device {
     /// }
     /// # anyhow::Result::<()>::Ok(()) });
     /// ```
-    pub async fn verify(&self) -> std::result::Result<(), ManualVerifyError> {
+    pub async fn verify(&self) -> Result<(), ManualVerifyError> {
         let request = self.inner.verify().await?;
         self.client.send(request, None).await?;
 
@@ -391,10 +391,7 @@ impl Device {
     /// # Arguments
     ///
     /// * `trust_state` - The new trust state that should be set for the device.
-    pub async fn set_local_trust(
-        &self,
-        trust_state: LocalTrust,
-    ) -> StdResult<(), CryptoStoreError> {
+    pub async fn set_local_trust(&self, trust_state: LocalTrust) -> Result<(), CryptoStoreError> {
         self.inner.set_local_trust(trust_state).await
     }
 }

crates/matrix-sdk/src/encryption/identities/users.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{result::Result, sync::Arc};
+use std::sync::Arc;
 
 use matrix_sdk_base::{
     crypto::{

crates/matrix-sdk/src/encryption/verification/qrcode.rs

@@ -71,7 +71,7 @@ impl QrVerification {
     ///
     /// The [`to_bytes()`](#method.to_bytes) method can be used to instead
     /// output the raw bytes that should be encoded as a QR code.
-    pub fn to_qr_code(&self) -> std::result::Result<QrCode, EncodingError> {
+    pub fn to_qr_code(&self) -> Result<QrCode, EncodingError> {
         self.inner.to_qr_code()
     }
 
@@ -80,7 +80,7 @@ impl QrVerification {
     ///
     /// The [`to_qr_code()`](#method.to_qr_code) method can be used to instead
     /// output a `QrCode` object that can be rendered.
-    pub fn to_bytes(&self) -> std::result::Result<Vec<u8>, EncodingError> {
+    pub fn to_bytes(&self) -> Result<Vec<u8>, EncodingError> {
         self.inner.to_bytes()
     }
 

crates/matrix-sdk/src/error.rs

@@ -40,7 +40,7 @@ use thiserror::Error;
 use url::ParseError as UrlParseError;
 
 /// Result type of the matrix-sdk.
-pub type Result<T> = std::result::Result<T, Error>;
+pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 /// Result type of a pure HTTP request.
 pub type HttpResult<T> = std::result::Result<T, HttpError>;

crates/matrix-sdk/src/room/joined.rs

@@ -170,7 +170,7 @@ impl Joined {
     /// if let Some(room) = client.get_joined_room(&room_id) {
     ///     room.typing_notice(true).await?
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn typing_notice(&self, typing: bool) -> Result<()> {
         // Only send a request to the homeserver if the old timeout has elapsed
@@ -278,7 +278,7 @@ impl Joined {
     /// if let Some(room) = client.get_joined_room(&room_id) {
     ///     room.enable_encryption().await?
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn enable_encryption(&self) -> Result<()> {
         use ruma::{
@@ -449,7 +449,7 @@ impl Joined {
     /// if let Some(room) = client.get_joined_room(&room_id) {
     ///     room.send(content, Some(txn_id)).await?;
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     ///
     /// [`SyncMessageEvent`]: ruma::events::SyncMessageEvent
@@ -517,7 +517,7 @@ impl Joined {
     /// if let Some(room) = client.get_joined_room(&room_id) {
     ///     room.send_raw(content, "m.room.message", None).await?;
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     ///
     /// [`SyncMessageEvent`]: ruma::events::SyncMessageEvent
@@ -631,7 +631,7 @@ impl Joined {
     ///         None,
     ///     ).await?;
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn send_attachment<R: Read>(
         &self,
@@ -698,7 +698,7 @@ impl Joined {
     /// if let Some(room) = client.get_joined_room(&room_id) {
     ///     room.send_state_event(content, "").await?;
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn send_state_event(
         &self,
@@ -791,7 +791,7 @@ impl Joined {
     ///     let reason = Some("Indecent material");
     ///     room.redact(&event_id, reason, None).await?;
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn redact(
         &self,
@@ -834,7 +834,7 @@ impl Joined {
     ///
     ///     room.set_tag("u.work", tag_info ).await?;
     /// }
-    /// # matrix_sdk::Result::Ok(()) });
+    /// # Result::<_, matrix_sdk::Error>::Ok(()) });
     /// ```
     pub async fn set_tag(&self, tag: &str, tag_info: TagInfo) -> HttpResult<create_tag::Response> {
         let user_id = self.client.user_id().await.ok_or(HttpError::AuthenticationRequired)?;