feat: (#45) Relax Sync + Send requirements

src/async/bus.rs

@@ -34,9 +34,11 @@ pub trait BusRequests<C: Client + ClientExt> {
     where
         S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/BusServices");
         client
-            .build_req_with_skip::<BusServiceResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<BusServiceResp, _>(
+                &concat_string!(client.base_url(), "/BusServices"),
+                skip.into(),
+            )
             .await
     }
 
@@ -48,9 +50,11 @@ pub trait BusRequests<C: Client + ClientExt> {
     where
         S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/BusRoutes");
         client
-            .build_req_with_skip::<BusRouteResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<BusRouteResp, _>(
+                &concat_string!(client.base_url(), "/BusRoutes"),
+                skip.into(),
+            )
             .await
     }
 
@@ -62,9 +66,11 @@ pub trait BusRequests<C: Client + ClientExt> {
     where
         S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/BusStops");
         client
-            .build_req_with_skip::<BusStopsResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<BusStopsResp, _>(
+                &concat_string!(client.base_url(), "/BusStops"),
+                skip.into(),
+            )
             .await
     }
 }

src/async/crowd.rs

@@ -8,7 +8,7 @@ use time::Date;
 use super::ClientExt;
 
 /// All APIs pertaining to transportation crowd
-pub trait CrowdRequests<C: Client + ClientExt + Send> {
+pub trait CrowdRequests<C: Client + ClientExt> {
     /// **Update freq**: By 15th of every month, the passenger volume for previous month data
     /// will be generated
     ///
@@ -20,8 +20,8 @@ pub trait CrowdRequests<C: Client + ClientExt + Send> {
         skip: S,
     ) -> LTAResult<Vec<String>>
     where
-        S: Into<Option<u32>> + Send,
-        D: Into<Option<Date>> + Send;
+        S: Into<Option<u32>>,
+        D: Into<Option<Date>>;
 
     /// Returns real-time platform crowdedness level for the MRT/LRT stations of a
     /// particular train network line

src/async/facility.rs

@@ -3,7 +3,7 @@ use crate::{Client, LTAResult};
 
 use super::ClientExt;
 
-pub trait FacilityRequests<C: Client + ClientExt + Send> {
+pub trait FacilityRequests<C: Client + ClientExt> {
     /// Returns pre-signed links to JSON file containing facilities maintenance schedules of the particular station
     ///
     /// **Update Freq**: Adhoc

src/async/geo.rs

@@ -2,7 +2,7 @@ use super::ClientExt;
 use crate::models::geo::prelude::*;
 use crate::{Client, LTAResult};
 
-pub trait GeoRequests<C: Client + ClientExt + Send> {
+pub trait GeoRequests<C: Client + ClientExt> {
     /// Returns the SHP files of the requested geospatial layer
     ///
     /// **Update Freq**: Adhoc

src/async/taxi.rs

@@ -5,18 +5,20 @@ use crate::{Client, LTAResult};
 use concat_string::concat_string;
 
 /// All APIs pertaining to taxis
-pub trait TaxiRequests<C: Client + ClientExt + Send> {
+pub trait TaxiRequests<C: Client + ClientExt> {
     /// Returns location coordinates of all Taxis that are currently available for
     /// hire. Does not include "Hired" or "Busy" Taxis.
     ///
     /// **Update freq**: 1min
     async fn get_taxi_avail<S>(client: &C, skip: S) -> LTAResult<Vec<Coordinates>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/Taxi-Availability");
         client
-            .build_req_with_skip::<TaxiAvailResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<TaxiAvailResp, _>(
+                &concat_string!(client.base_url(), "/Taxi-Availability"),
+                skip.into(),
+            )
             .await
     }
 
@@ -25,11 +27,13 @@ pub trait TaxiRequests<C: Client + ClientExt + Send> {
     /// **Update freq**: Monthly
     async fn get_taxi_stands<S>(client: &C, skip: S) -> LTAResult<Vec<TaxiStand>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/TaxiStands");
         client
-            .build_req_with_skip::<TaxiStandsResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<TaxiStandsResp, _>(
+                &concat_string!(client.base_url(), "/TaxiStands"),
+                skip.into(),
+            )
             .await
     }
 }

src/async/traffic.rs

@@ -4,18 +4,20 @@ use concat_string::concat_string;
 
 use super::ClientExt;
 
-pub trait TrafficRequests<C: Client + ClientExt + Send + Sync> {
+pub trait TrafficRequests<C: Client + ClientExt> {
     /// Returns ERP rates of all vehicle types across all timings for each
     /// zone.
     ///
     /// **Update freq**: Ad-Hoc
     async fn get_erp_rates<S>(client: &C, skip: S) -> LTAResult<Vec<ErpRate>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/ERPRates");
         client
-            .build_req_with_skip::<ErpRatesResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<ErpRatesResp, _>(
+                &concat_string!(client.base_url(), "/ERPRates"),
+                skip.into(),
+            )
             .await
     }
 
@@ -28,11 +30,13 @@ pub trait TrafficRequests<C: Client + ClientExt + Send + Sync> {
     /// **Update freq**: 1 min
     async fn get_carpark_avail<S>(client: &C, skip: S) -> LTAResult<Vec<CarPark>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/CarParkAvailabilityv2");
         client
-            .build_req_with_skip::<CarparkAvailResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<CarparkAvailResp, _>(
+                &concat_string!(client.base_url(), "/CarParkAvailabilityv2"),
+                skip.into(),
+            )
             .await
     }
 
@@ -41,11 +45,13 @@ pub trait TrafficRequests<C: Client + ClientExt + Send + Sync> {
     /// **Update freq**: 5min
     async fn get_est_travel_time<S>(client: &C, skip: S) -> LTAResult<Vec<EstTravelTime>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/EstTravelTimes");
         client
-            .build_req_with_skip::<EstTravelTimeResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<EstTravelTimeResp, _>(
+                &concat_string!(client.base_url(), "/EstTravelTimes"),
+                skip.into(),
+            )
             .await
     }
 
@@ -55,11 +61,13 @@ pub trait TrafficRequests<C: Client + ClientExt + Send + Sync> {
     /// **Update freq**: 2min or whenever there are updates
     async fn get_faulty_traffic_lights<S>(client: &C, skip: S) -> LTAResult<Vec<FaultyTrafficLight>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/FaultyTrafficLights");
         client
-            .build_req_with_skip::<FaultyTrafficLightResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<FaultyTrafficLightResp, _>(
+                &concat_string!(client.base_url(), "/FaultyTrafficLights"),
+                skip.into(),
+            )
             .await
     }
 
@@ -72,7 +80,7 @@ pub trait TrafficRequests<C: Client + ClientExt + Send + Sync> {
         skip: S,
     ) -> LTAResult<Vec<RoadDetails>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
         let url = match road_details_type {
             RoadDetailsType::RoadOpening => concat_string!(client.base_url(), "/RoadOpenings"),
@@ -81,7 +89,7 @@ pub trait TrafficRequests<C: Client + ClientExt + Send + Sync> {
         };
 
         client
-            .build_req_with_skip::<RoadDetailsResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<RoadDetailsResp, _>(&url, skip.into())
             .await
     }
 
@@ -91,11 +99,13 @@ pub trait TrafficRequests<C: Client + ClientExt + Send + Sync> {
     /// **Update freq**: 5 minutes
     async fn get_traffic_speed_band<S>(client: &C, skip: S) -> LTAResult<Vec<TrafficSpeedBand>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/v3/TrafficSpeedBands");
         client
-            .build_req_with_skip::<TrafficSpeedBandResp, _>(url.as_str(), skip.into())
+            .build_req_with_skip::<TrafficSpeedBandResp, _>(
+                &concat_string!(client.base_url(), "/v3/TrafficSpeedBands"),
+                skip.into(),
+            )
             .await
     }
 
@@ -105,7 +115,7 @@ pub trait TrafficRequests<C: Client + ClientExt + Send + Sync> {
     /// **Update freq**: 1 to 5 minutes
     async fn get_traffic_images<S>(client: &C, skip: S) -> LTAResult<Vec<TrafficImage>>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
         let url = concat_string!(client.base_url(), "/Traffic-Imagesv2");
         client

src/async/train.rs

@@ -4,18 +4,20 @@ use concat_string::concat_string;
 
 use super::ClientExt;
 
-pub trait TrainRequests<C: Client + ClientExt + Send + Sync> {
+pub trait TrainRequests<C: Client + ClientExt> {
     /// Returns detailed information on train service unavailability during scheduled
     /// operating hours, such as affected line and stations etc.
     ///
     /// **Update freq**: ad-hoc
     async fn get_train_service_alert<S>(client: &C, skip: S) -> LTAResult<TrainServiceAlert>
     where
-        S: Into<Option<u32>> + Send,
+        S: Into<Option<u32>>,
     {
-        let url = concat_string!(client.base_url(), "/TrainServiceAlerts");
         client
-            .build_req_with_skip::<TrainServiceAlertResp, _>(url.as_ref(), skip.into())
+            .build_req_with_skip::<TrainServiceAlertResp, _>(
+                &concat_string!(client.base_url(), "/TrainServiceAlerts"),
+                skip.into(),
+            )
             .await
     }
 }

src/reqwest_async/bus.rs

@@ -19,7 +19,7 @@ impl BusRequests<LTAClient<ReqwestAsync>> for Bus {
         match service_no.into() {
             Some(srv_no) => {
                 client
-                    .build_req_with_query::<RawBusArrivalResp, _, _>(url.as_str(), |rb| {
+                    .build_req_with_query::<RawBusArrivalResp, _, _>(&url, |rb| {
                         rb.query(&[
                             ("BusStopCode", bus_stop_code.to_string().as_str()),
                             ("ServiceNo", srv_no),
@@ -29,7 +29,7 @@ impl BusRequests<LTAClient<ReqwestAsync>> for Bus {
             }
             None => {
                 client
-                    .build_req_with_query::<RawBusArrivalResp, _, _>(url.as_str(), |rb| {
+                    .build_req_with_query::<RawBusArrivalResp, _, _>(&url, |rb| {
                         rb.query(&[("BusStopCode", bus_stop_code.to_string())])
                     })
                     .await

src/reqwest_async/crowd.rs

@@ -21,8 +21,8 @@ impl CrowdRequests<LTAClient<ReqwestAsync>> for Crowd {
         skip: S,
     ) -> LTAResult<Vec<String>>
     where
-        S: Into<Option<u32>> + Send,
-        D: Into<Option<Date>> + Send,
+        S: Into<Option<u32>>,
+        D: Into<Option<Date>>,
     {
         let format = format_description!("[year]-[month]-[day]");
         let fmt_date = date
@@ -36,18 +36,14 @@ impl CrowdRequests<LTAClient<ReqwestAsync>> for Crowd {
         match fmt_date {
             Some(nd) => {
                 client
-                    .build_req_with_query::<passenger_vol::PassengerVolRawResp, _, _>(
-                        url.as_str(),
-                        |rb| rb.query(&[("Date", nd)]),
-                    )
+                    .build_req_with_query::<passenger_vol::PassengerVolRawResp, _, _>(&url, |rb| {
+                        rb.query(&[("Date", nd)])
+                    })
                     .await
             }
             None => {
                 client
-                    .build_req_with_skip::<passenger_vol::PassengerVolRawResp, _>(
-                        url.as_str(),
-                        skip.into(),
-                    )
+                    .build_req_with_skip::<passenger_vol::PassengerVolRawResp, _>(&url, skip.into())
                     .await
             }
         }
@@ -57,23 +53,23 @@ impl CrowdRequests<LTAClient<ReqwestAsync>> for Crowd {
         client: &LTAClient<ReqwestAsync>,
         train_line: MrtLine,
     ) -> LTAResult<Vec<StationCrowdLevel>> {
-        let url = concat_string!(client.base_url(), "/PCDRealTime");
         client
-            .build_req_with_query::<StationCrowdLevelRawResp, _, _>(url.as_str(), |rb| {
-                rb.query(&[("TrainLine", train_line)])
-            })
+            .build_req_with_query::<StationCrowdLevelRawResp, _, _>(
+                &concat_string!(client.base_url(), "/PCDRealTime"),
+                |rb| rb.query(&[("TrainLine", train_line)]),
+            )
             .await
     }
 
     async fn get_crowd_density_forecast(
         client: &LTAClient<ReqwestAsync>,
         train_line: MrtLine,
     ) -> LTAResult<CrowdDensityForecast> {
-        let url = concat_string!(client.base_url(), "/PCDForecast");
         client
-            .build_req_with_query::<CrowdDensityForecastRawResp, _, _>(url.as_str(), |rb| {
-                rb.query(&[("TrainLine", train_line)])
-            })
+            .build_req_with_query::<CrowdDensityForecastRawResp, _, _>(
+                &concat_string!(client.base_url(), "/PCDForecast"),
+                |rb| rb.query(&[("TrainLine", train_line)]),
+            )
             .await
     }
 }

src/reqwest_async/facility.rs

@@ -11,11 +11,11 @@ impl FacilityRequests<LTAClient<ReqwestAsync>> for Facility {
         client: &LTAClient<ReqwestAsync>,
         station_code: StationCode,
     ) -> LTAResult<Vec<String>> {
-        let url = concat_string!(client.base_url(), "/FacilitiesMaintenance");
         client
-            .build_req_with_query::<FacilityMaintenanceRawResp, _, _>(url.as_str(), |rb| {
-                rb.query(&[("StationCode", station_code)])
-            })
+            .build_req_with_query::<FacilityMaintenanceRawResp, _, _>(
+                &concat_string!(client.base_url(), "/FacilitiesMaintenance"),
+                |rb| rb.query(&[("StationCode", station_code)]),
+            )
             .await
     }
 }

src/reqwest_async/geo.rs

@@ -10,11 +10,11 @@ impl GeoRequests<LTAClient<ReqwestAsync>> for Geo {
         client: &LTAClient<ReqwestAsync>,
         id: GeospatialLayerId,
     ) -> LTAResult<Vec<String>> {
-        let url = concat_string!(client.base_url(), "/GeospatialWholeIsland");
         client
-            .build_req_with_query::<GeospatialWholeIslandRawResp, _, _>(url.as_str(), |rb| {
-                rb.query(&[("ID", id)])
-            })
+            .build_req_with_query::<GeospatialWholeIslandRawResp, _, _>(
+                &concat_string!(client.base_url(), "/GeospatialWholeIsland"),
+                |rb| rb.query(&[("ID", id)]),
+            )
             .await
     }
 }