From 74b11708068107406d447e918d77c36bd3ee284b Mon Sep 17 00:00:00 2001
From: Henry Zimmerman <zimhen7@gmail.com>
Date: Wed, 18 Dec 2019 06:43:44 -0500
Subject: [PATCH 1/2] rename the type parameter that indicates history state

---
 src/components/mod.rs           |  4 ++--
 src/components/router_button.rs | 10 +++++-----
 src/components/router_link.rs   | 10 +++++-----
 src/route.rs                    | 14 +++++++-------
 src/router.rs                   |  8 ++++----
 src/service.rs                  | 30 +++++++++++++++---------------
 src/switch.rs                   | 22 +++++++++++-----------
 7 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/src/components/mod.rs b/src/components/mod.rs
index a3cdf41..77797d2 100644
--- a/src/components/mod.rs
+++ b/src/components/mod.rs
@@ -16,11 +16,11 @@ use crate::RouterState;
 // TODO This should no longer take link & String, and instead take a route: T implementing Switch
 /// Properties for `RouterButton` and `RouterLink`.
 #[derive(Properties, Default, Debug)]
-pub struct Props<T: RouterState> {
+pub struct Props<STATE: RouterState> {
     /// The route that will be set when the component is clicked.
     pub link: String,
     /// The state to set when changing the route.
-    pub state: T,
+    pub state: STATE,
     #[deprecated(note = "Use children field instead (nested html)")]
     /// The text to display.
     pub text: String,
diff --git a/src/components/router_button.rs b/src/components/router_button.rs
index c2b9bca..ba470ce 100644
--- a/src/components/router_button.rs
+++ b/src/components/router_button.rs
@@ -11,15 +11,15 @@ use yew::virtual_dom::VNode;
 
 /// Changes the route when clicked.
 #[derive(Debug)]
-pub struct RouterButton<T: RouterState = ()> {
+pub struct RouterButton<STATE: RouterState = ()> {
     link: ComponentLink<Self>,
-    router: RouteAgentDispatcher<T>,
-    props: Props<T>,
+    router: RouteAgentDispatcher<STATE>,
+    props: Props<STATE>,
 }
 
-impl<T: RouterState> Component for RouterButton<T> {
+impl<STATE: RouterState> Component for RouterButton<STATE> {
     type Message = Msg;
-    type Properties = Props<T>;
+    type Properties = Props<STATE>;
 
     fn create(props: Self::Properties, link: ComponentLink<Self>) -> Self {
         let router = RouteAgentDispatcher::new();
diff --git a/src/components/router_link.rs b/src/components/router_link.rs
index 9a04a33..1781e99 100644
--- a/src/components/router_link.rs
+++ b/src/components/router_link.rs
@@ -17,15 +17,15 @@ pub type RouterLink<T> = RouterAnchor<T>;
 
 /// An anchor tag Component that when clicked, will navigate to the provided route.
 #[derive(Debug)]
-pub struct RouterAnchor<T: RouterState = ()> {
+pub struct RouterAnchor<STATE: RouterState = ()> {
     link: ComponentLink<Self>,
-    router: RouteAgentDispatcher<T>,
-    props: Props<T>,
+    router: RouteAgentDispatcher<STATE>,
+    props: Props<STATE>,
 }
 
-impl<T: RouterState> Component for RouterAnchor<T> {
+impl<STATE: RouterState> Component for RouterAnchor<STATE> {
     type Message = Msg;
-    type Properties = Props<T>;
+    type Properties = Props<STATE>;
 
     fn create(props: Self::Properties, link: ComponentLink<Self>) -> Self {
         let router = RouteAgentDispatcher::new();
diff --git a/src/route.rs b/src/route.rs
index b80affc..d6f955a 100644
--- a/src/route.rs
+++ b/src/route.rs
@@ -16,11 +16,11 @@ impl<T> RouteState for T where T: Serialize + DeserializeOwned + Debug + Clone +
 
 /// The representation of a route, segmented into different sections for easy access.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct Route<T = ()> {
+pub struct Route<STATE = ()> {
     /// The route string
     pub route: String,
     /// The state stored in the history api
-    pub state: T,
+    pub state: STATE,
 }
 
 
@@ -36,23 +36,23 @@ impl Route<()> {
     }
 }
 
-impl <T: Default> Route<T> {
+impl <STATE: Default> Route<STATE> {
     /// Creates a new route out of a string, setting the state to its default value.
-    pub fn new_default_state<U: AsRef<str>>(route: U) -> Self {
+    pub fn new_default_state<T: AsRef<str>>(route: T) -> Self {
         Route {
             route: route.as_ref().to_string(),
-            state: T::default(),
+            state: STATE::default(),
         }
     }
 }
 
-impl<T> fmt::Display for Route<T> {
+impl<STATE> fmt::Display for Route<STATE> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         std::fmt::Display::fmt(&self.route, f)
     }
 }
 
-impl<T> Deref for Route<T> {
+impl<STATE> Deref for Route<STATE> {
     type Target = String;
 
     fn deref(&self) -> &Self::Target {
diff --git a/src/router.rs b/src/router.rs
index 66186a1..db68e1a 100644
--- a/src/router.rs
+++ b/src/router.rs
@@ -162,13 +162,13 @@ impl<T: RouterState, SW: Switch + Clone> Debug for Props<T, SW> {
     }
 }
 
-impl<T, SW> Component for Router<SW, T>
+impl<STATE, SW> Component for Router<SW, STATE>
 where
-    T: RouterState,
+    STATE: RouterState,
     SW: Switch + Clone + 'static,
 {
-    type Message = Msg<T>;
-    type Properties = Props<T, SW>;
+    type Message = Msg<STATE>;
+    type Properties = Props<STATE, SW>;
 
     fn create(props: Self::Properties, link: ComponentLink<Self>) -> Self {
         let callback = link.callback(Msg::UpdateRoute);
diff --git a/src/service.rs b/src/service.rs
index f80ae9b..bc50109 100644
--- a/src/service.rs
+++ b/src/service.rs
@@ -14,19 +14,19 @@ use stdweb::js;
 ///
 /// The `T` determines what route state can be stored in the route service.
 #[derive(Debug)]
-pub struct RouteService<T = ()> {
+pub struct RouteService<STATE = ()> {
     history: History,
     location: Location,
     event_listener: Option<EventListenerHandle>,
-    phantom_data: PhantomData<T>,
+    phantom_data: PhantomData<STATE>,
 }
 
-impl<T> Default for RouteService<T>
+impl<STATE> Default for RouteService<STATE>
 where
-    T: RouteState,
+    STATE: RouteState,
 {
     fn default() -> Self {
-        RouteService::<T>::new()
+        RouteService::<STATE>::new()
     }
 }
 
@@ -70,20 +70,20 @@ impl<T> RouteService<T> {
     }
 }
 
-impl<T> RouteService<T>
+impl<STATE> RouteService<STATE>
 where
-    T: RouteState,
+    STATE: RouteState,
 {
     /// Registers a callback to the route service.
     /// Callbacks will be called when the History API experiences a change such as
     /// popping a state off of its stack when the forward or back buttons are pressed.
-    pub fn register_callback(&mut self, callback: Callback<Route<T>>) {
+    pub fn register_callback(&mut self, callback: Callback<Route<STATE>>) {
         self.event_listener = Some(window().add_event_listener(move |event: PopStateEvent| {
             let state_value: Value = event.state();
             let state_string: String = String::try_from(state_value).unwrap_or_default();
-            let state: T = serde_json::from_str(&state_string).unwrap_or_else(|_| {
+            let state: STATE = serde_json::from_str(&state_string).unwrap_or_else(|_| {
                 log::error!("Could not deserialize state string");
-                T::default()
+                STATE::default()
             });
 
 
@@ -101,7 +101,7 @@ where
     /// and creates a history entry that can be navigated via the forward and back buttons.
     ///
     /// The route should be a relative path that starts with a `/`.
-    pub fn set_route(&mut self, route: &str, state: T) {
+    pub fn set_route(&mut self, route: &str, state: STATE) {
         let state_string: String = serde_json::to_string(&state).unwrap_or_else(|_| {
             log::error!("Could not serialize state string");
             "".to_string()
@@ -111,7 +111,7 @@ where
 
     /// Replaces the route with another one removing the most recent history event and
     /// creating another history event in its place.
-    pub fn replace_route(&mut self, route: &str, state: T) {
+    pub fn replace_route(&mut self, route: &str, state: STATE) {
         let state_string: String = serde_json::to_string(&state).unwrap_or_else(|_| {
             log::error!("Could not serialize state string");
             "".to_string()
@@ -120,14 +120,14 @@ where
     }
 
     /// Gets the concatenated path, query, and fragment.
-    pub fn get_route(&self) -> Route<T> {
+    pub fn get_route(&self) -> Route<STATE> {
         let route_string = Self::get_route_from_location(&self.location);
-        let state: T = get_state_string(&self.history)
+        let state: STATE = get_state_string(&self.history)
             .or_else(|| {
                 log::trace!("History state is empty");
                 None
             })
-            .and_then(|state_string| -> Option<Option<T>>{
+            .and_then(|state_string| -> Option<Option<STATE>>{
                 serde_json::from_str(&state_string)
                     .ok()
                     .or_else(|| {
diff --git a/src/switch.rs b/src/switch.rs
index 736a649..ad3978e 100644
--- a/src/switch.rs
+++ b/src/switch.rs
@@ -49,15 +49,15 @@ pub type Routable = Switch;
 /// ```
 pub trait Switch: Sized {
     /// Based on a route, possibly produce an itself.
-    fn switch<T>(route: Route<T>) -> Option<Self> {
+    fn switch<STATE>(route: Route<STATE>) -> Option<Self> {
         Self::from_route_part(route.route, Some(route.state)).0
     }
 
     /// Get self from a part of the state
-    fn from_route_part<T>(part: String, state: Option<T>) -> (Option<Self>, Option<T>);
+    fn from_route_part<STATE>(part: String, state: Option<STATE>) -> (Option<Self>, Option<STATE>);
 
     /// Build part of a route from itself.
-    fn build_route_section<T>(self, route: &mut String) -> Option<T>;
+    fn build_route_section<STATE>(self, route: &mut String) -> Option<STATE>;
 
     /// Called when the key (the named capture group) can't be located. Instead of failing outright,
     /// a default item can be provided instead.
@@ -81,7 +81,7 @@ pub trait Switch: Sized {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct LeadingSlash<T>(pub T);
 impl<U: Switch> Switch for LeadingSlash<U> {
-    fn from_route_part<T>(part: String, state: Option<T>) -> (Option<Self>, Option<T>) {
+    fn from_route_part<STATE>(part: String, state: Option<STATE>) -> (Option<Self>, Option<STATE>) {
         if part.starts_with('/') {
             let part =  part[1..].to_string();
             let (inner, state) = U::from_route_part(part, state);
@@ -103,7 +103,7 @@ pub struct Permissive<U>(pub Option<U>);
 
 impl<U: Switch> Switch for Permissive<U> {
     /// Option is very permissive in what is allowed.
-    fn from_route_part<T>(part: String, state: Option<T>) -> (Option<Self>, Option<T>) {
+    fn from_route_part<STATE>(part: String, state: Option<STATE>) -> (Option<Self>, Option<STATE>) {
         let (inner, inner_state) = U::from_route_part(part, state);
         if inner.is_some() {
             (Some(Permissive(inner)), inner_state)
@@ -113,7 +113,7 @@ impl<U: Switch> Switch for Permissive<U> {
         }
     }
 
-    fn build_route_section<T>(self, route: &mut String) -> Option<T> {
+    fn build_route_section<STATE>(self, route: &mut String) -> Option<STATE> {
         if let Some(inner) = self.0 {
             inner.build_route_section(route)
         } else {
@@ -134,7 +134,7 @@ impl<U: Switch> Switch for Permissive<U> {
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub struct AllowMissing<U: std::fmt::Debug>(pub Option<U>);
 impl<U: Switch + std::fmt::Debug> Switch for AllowMissing<U> {
-    fn from_route_part<T>(part: String, state: Option<T>) -> (Option<Self>, Option<T>) {
+    fn from_route_part<STATE>(part: String, state: Option<STATE>) -> (Option<Self>, Option<STATE>) {
         let route = part.clone();
         let (inner, inner_state) = U::from_route_part(part, state);
 
@@ -152,7 +152,7 @@ impl<U: Switch + std::fmt::Debug> Switch for AllowMissing<U> {
         }
     }
 
-    fn build_route_section<T>(self, route: &mut String) -> Option<T> {
+    fn build_route_section<STATE>(self, route: &mut String) -> Option<STATE> {
         if let AllowMissing(Some(inner)) = self {
             inner.build_route_section(route)
         } else {
@@ -162,19 +162,19 @@ impl<U: Switch + std::fmt::Debug> Switch for AllowMissing<U> {
 }
 
 /// Builds a route from a switch.
-fn build_route_from_switch<T: Switch, U: Default>(switch: T) -> Route<U> {
+fn build_route_from_switch<SW: Switch, STATE: Default>(switch: SW) -> Route<STATE> {
     // URLs are recommended to not be over 255 characters,
     // although browsers frequently support up to about 2000.
     // Routes, being a subset of URLs should probably be smaller than 255 characters for the vast
     // majority of circumstances, preventing reallocation under most conditions.
     let mut buf = String::with_capacity(255);
-    let state = switch.build_route_section(&mut buf).unwrap_or_default();
+    let state: STATE = switch.build_route_section(&mut buf).unwrap_or_default();
     buf.shrink_to_fit();
 
     Route { route: buf, state }
 }
 
-impl<SW: Switch, T: Default> From<SW> for Route<T> {
+impl<SW: Switch, STATE: Default> From<SW> for Route<STATE> {
     fn from(switch: SW) -> Self {
         build_route_from_switch(switch)
     }

From ad294b773e27e106dc22fd0483016b4b97c60333 Mon Sep 17 00:00:00 2001
From: Henry Zimmerman <zimhen7@gmail.com>
Date: Wed, 18 Dec 2019 06:54:19 -0500
Subject: [PATCH 2/2] update agent

---
 src/agent/bridge.rs     | 20 ++++++++++----------
 src/agent/dispatcher.rs | 18 +++++++++---------
 src/agent/mod.rs        | 26 +++++++++++++-------------
 src/router.rs           | 38 +++++++++++++++++++-------------------
 4 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/src/agent/bridge.rs b/src/agent/bridge.rs
index 3d05825..c31dbc0 100644
--- a/src/agent/bridge.rs
+++ b/src/agent/bridge.rs
@@ -12,16 +12,16 @@ use yew::{
 /// A wrapped bridge to the route agent.
 ///
 /// A component that owns this can send and receive messages from the agent.
-pub struct RouteAgentBridge<T = ()>(Box<dyn Bridge<RouteAgent<T>>>)
+pub struct RouteAgentBridge<STATE = ()>(Box<dyn Bridge<RouteAgent<STATE>>>)
 where
-    T: RouteState;
+    STATE: RouteState;
 
-impl<T> RouteAgentBridge<T>
+impl<STATE> RouteAgentBridge<STATE>
 where
-    T: RouteState,
+    STATE: RouteState,
 {
     /// Creates a new bridge.
-    pub fn new(callback: Callback<Route<T>>) -> Self {
+    pub fn new(callback: Callback<Route<STATE>>) -> Self {
         let router_agent = RouteAgent::bridge(callback);
         RouteAgentBridge(router_agent)
     }
@@ -29,27 +29,27 @@ where
     /// Experimental, may be removed
     ///
     /// Directly spawn a new Router
-    pub fn spawn(callback: Callback<Route<T>>) -> Self {
+    pub fn spawn(callback: Callback<Route<STATE>>) -> Self {
         use yew::agent::Discoverer;
         let router_agent = Context::spawn_or_join(Some(callback));
         RouteAgentBridge(router_agent)
     }
 }
 
-impl<T: RouteState> Debug for RouteAgentBridge<T> {
+impl<STATE: RouteState> Debug for RouteAgentBridge<STATE> {
     fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
         f.debug_tuple("RouteAgentBridge").finish()
     }
 }
 
-impl<T: RouteState> Deref for RouteAgentBridge<T> {
-    type Target = Box<dyn Bridge<RouteAgent<T>>>;
+impl<STATE: RouteState> Deref for RouteAgentBridge<STATE> {
+    type Target = Box<dyn Bridge<RouteAgent<STATE>>>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
-impl<T: RouteState> DerefMut for RouteAgentBridge<T> {
+impl<STATE: RouteState> DerefMut for RouteAgentBridge<STATE> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
diff --git a/src/agent/dispatcher.rs b/src/agent/dispatcher.rs
index b1fd0f9..5e35f97 100644
--- a/src/agent/dispatcher.rs
+++ b/src/agent/dispatcher.rs
@@ -10,13 +10,13 @@ use crate::RouteState;
 /// A wrapped dispatcher to the route agent.
 ///
 /// A component that owns and instance of this can send messages to the RouteAgent, but not receive them.
-pub struct RouteAgentDispatcher<T = ()>(Dispatcher<RouteAgent<T>>)
+pub struct RouteAgentDispatcher<STATE = ()>(Dispatcher<RouteAgent<STATE>>)
 where
-    T: RouteState;
+    STATE: RouteState;
 
-impl<T> RouteAgentDispatcher<T>
+impl<STATE> RouteAgentDispatcher<STATE>
 where
-    T: RouteState
+    STATE: RouteState
 {
     /// Creates a new bridge.
     pub fn new() -> Self {
@@ -25,23 +25,23 @@ where
     }
 }
 
-impl<T> Default for RouteAgentDispatcher<T>
+impl<STATE> Default for RouteAgentDispatcher<STATE>
 where
-    T: RouteState
+    STATE: RouteState
 {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<T: RouteState> Debug for RouteAgentDispatcher<T> {
+impl<STATE: RouteState> Debug for RouteAgentDispatcher<STATE> {
     fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
         f.debug_tuple("RouteAgentDispatcher").finish()
     }
 }
 
-impl<T: RouteState> Deref for RouteAgentDispatcher<T> {
-    type Target = Dispatcher<RouteAgent<T>>;
+impl<STATE: RouteState> Deref for RouteAgentDispatcher<STATE> {
+    type Target = Dispatcher<RouteAgent<STATE>>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
diff --git a/src/agent/mod.rs b/src/agent/mod.rs
index a132e5f..e92dcab 100644
--- a/src/agent/mod.rs
+++ b/src/agent/mod.rs
@@ -24,9 +24,9 @@ pub use dispatcher::RouteAgentDispatcher;
 
 /// Internal Message used for the RouteAgent.
 #[derive(Debug)]
-pub enum Msg<T> {
+pub enum Msg<STATE> {
     /// Message for when the route is changed.
-    BrowserNavigationRouteChanged(Route<T>), // TODO make this a route?
+    BrowserNavigationRouteChanged(Route<STATE>), // TODO make this a route?
 }
 
 /// Input message type for interacting with the `RouteAgent'.
@@ -57,22 +57,22 @@ pub enum RouteRequest<T = ()> {
 ///
 /// If you use multiple agents with different types, then the Agents won't be able to communicate to
 /// each other and associated components may not work as intended.
-pub struct RouteAgent<T = ()>
+pub struct RouteAgent<STATE = ()>
 where
-    T: RouteState,
+    STATE: RouteState,
 {
     // In order to have the AgentLink<Self> below, apparently T must be constrained like this.
     // Unfortunately, this means that everything related to an agent requires this constraint.
-    link: AgentLink<RouteAgent<T>>,
+    link: AgentLink<RouteAgent<STATE>>,
     /// The service through which communication with the browser happens.
-    route_service: RouteService<T>,
+    route_service: RouteService<STATE>,
     /// A list of all entities connected to the router.
     /// When a route changes, either initiated by the browser or by the app,
     /// the route change will be broadcast to all listening entities.
     subscribers: HashSet<HandlerId>,
 }
 
-impl<T: RouteState> Debug for RouteAgent<T> {
+impl<STATE: RouteState> Debug for RouteAgent<STATE> {
     fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
         f.debug_struct("RouteAgent")
             .field("link", &"-")
@@ -82,16 +82,16 @@ impl<T: RouteState> Debug for RouteAgent<T> {
     }
 }
 
-impl<T> Agent for RouteAgent<T>
+impl<STATE> Agent for RouteAgent<STATE>
 where
-    T: RouteState,
+    STATE: RouteState,
 {
-    type Input = RouteRequest<T>;
-    type Message = Msg<T>;
-    type Output = Route<T>;
+    type Input = RouteRequest<STATE>;
+    type Message = Msg<STATE>;
+    type Output = Route<STATE>;
     type Reach = Context;
 
-    fn create(link: AgentLink<RouteAgent<T>>) -> Self {
+    fn create(link: AgentLink<RouteAgent<STATE>>) -> Self {
         let callback = link.callback(Msg::BrowserNavigationRouteChanged);
         let mut route_service = RouteService::new();
         route_service.register_callback(callback);
diff --git a/src/router.rs b/src/router.rs
index db68e1a..d111deb 100644
--- a/src/router.rs
+++ b/src/router.rs
@@ -10,7 +10,7 @@ use yew::{html, virtual_dom::VNode, Component, ComponentLink, Html, Properties,
 
 /// Any state that can be managed by the `Router` must meet the criteria of this trait.
 pub trait RouterState: RouteState + PartialEq  {}
-impl<T> RouterState for T where T: RouteState + PartialEq {}
+impl<STATE> RouterState for STATE where STATE: RouteState + PartialEq {}
 
 /// Rendering control flow component.
 ///
@@ -54,15 +54,15 @@ impl<T> RouterState for T where T: RouteState + PartialEq {}
 /// ```
 // TODO, can M just be removed due to not having to explicitly deal with callbacks anymore? - Just get rid of M
 #[derive(Debug)]
-pub struct Router<SW: Switch + Clone + 'static, T: RouterState = ()> {
+pub struct Router<SW: Switch + Clone + 'static, STATE: RouterState = ()> {
     switch: Option<SW>,
-    props: Props<T, SW>,
-    router_agent: RouteAgentBridge<T>,
+    props: Props<STATE, SW>,
+    router_agent: RouteAgentBridge<STATE>,
 }
 
-impl<SW, T> Router<SW, T>
+impl<SW, STATE> Router<SW, STATE>
 where
-    T: RouterState,
+    STATE: RouterState,
     SW: Switch + Clone + 'static,
 {
     // TODO render fn name is overloaded now with that of the trait: Renderable<_> this should be changed. Maybe: display, show, switch, inner...
@@ -87,21 +87,21 @@ where
     /// });
     /// # }
     /// ```
-    pub fn render<F: RenderFn<Router<SW, T>, SW> + 'static>(f: F) -> Render<SW, T> {
+    pub fn render<F: RenderFn<Router<SW, STATE>, SW> + 'static>(f: F) -> Render<SW, STATE> {
         Render::new(f)
     }
 
     /// Wrap a redirect function so that it can be used by the Router.
-    pub fn redirect<F: RedirectFn<SW, T> + 'static>(f: F) -> Option<Redirect<SW, T>> {
+    pub fn redirect<F: RedirectFn<SW, STATE> + 'static>(f: F) -> Option<Redirect<SW, STATE>> {
         Some(Redirect::new(f))
     }
 }
 
 /// Message for Router.
 #[derive(Debug, Clone)]
-pub enum Msg<T> {
+pub enum Msg<STATE> {
     /// Updates the route
-    UpdateRoute(Route<T>),
+    UpdateRoute(Route<STATE>),
 }
 
 /// Render function that takes a switched route and converts it to HTML
@@ -109,16 +109,16 @@ pub trait RenderFn<CTX: Component, SW>: Fn(SW) -> Html {}
 impl<T, CTX: Component, SW> RenderFn<CTX, SW> for T where T: Fn(SW) -> Html {}
 /// Owned Render function.
 #[derive(Clone)]
-pub struct Render<SW: Switch + Clone + 'static, T: RouterState = ()>(
-    pub(crate) Rc<dyn RenderFn<Router<SW, T>, SW>>,
+pub struct Render<SW: Switch + Clone + 'static, STATE: RouterState = ()>(
+    pub(crate) Rc<dyn RenderFn<Router<SW, STATE>, SW>>,
 );
-impl<T: RouterState, SW: Switch + Clone> Render<SW, T> {
+impl<STATE: RouterState, SW: Switch + Clone> Render<SW, STATE> {
     /// New render function
-    fn new<F: RenderFn<Router<SW, T>, SW> + 'static>(f: F) -> Self {
+    fn new<F: RenderFn<Router<SW, STATE>, SW> + 'static>(f: F) -> Self {
         Render(Rc::new(f))
     }
 }
-impl<T: RouterState, SW: Switch + Clone> Debug for Render<SW, T> {
+impl<STATE: RouterState, SW: Switch + Clone> Debug for Render<SW, STATE> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.debug_struct("Render").finish()
     }
@@ -146,17 +146,17 @@ impl<STATE: RouterState, SW: Switch> Debug for Redirect<SW, STATE> {
 
 /// Properties for Router.
 #[derive(Properties, Clone)]
-pub struct Props<T: RouterState, SW: Switch + Clone + 'static> {
+pub struct Props<STATE: RouterState, SW: Switch + Clone + 'static> {
     /// Render function that takes a Switch and produces Html
     #[props(required)]
-    pub render: Render<SW, T>,
+    pub render: Render<SW, STATE>,
     /// Optional redirect function that will convert the route to a known switch variant if explicit matching fails.
     /// This should mostly be used to handle 404s and redirection.
     /// It is not strictly necessary as your Switch is capable of handling unknown routes using `#[to="/{*:any}"]`.
-    pub redirect: Option<Redirect<SW, T>>,
+    pub redirect: Option<Redirect<SW, STATE>>,
 }
 
-impl<T: RouterState, SW: Switch + Clone> Debug for Props<T, SW> {
+impl<STATE: RouterState, SW: Switch + Clone> Debug for Props<STATE, SW> {
     fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
         f.debug_struct("Props").finish()
     }