[REFACTOR]: reduced where usages

src/error.rs

@@ -72,10 +72,7 @@ pub enum BleurError {
     Unknown,
 }
 
-pub fn beautiful_exit<T>(message: T) -> !
-where
-    T: AsRef<str>,
-{
+pub fn beautiful_exit<T: AsRef<str>>(message: T) -> ! {
     eprintln!("{} {}", "error:".red(), message.as_ref());
 
     std::process::exit(1)

src/manager.rs

@@ -37,10 +37,7 @@ impl ManageBuilder {
         })
     }
 
-    pub fn source<T>(self, url: T) -> Result<Self>
-    where
-        T: AsRef<str>,
-    {
+    pub fn source<T: AsRef<str>>(self, url: T) -> Result<Self> {
         Ok(Self {
             temporary: self.temporary,
             method: self.method,
@@ -51,10 +48,7 @@ impl ManageBuilder {
         })
     }
 
-    pub fn fetch_method<T>(self, method: T) -> Result<Self>
-    where
-        T: Methodical,
-    {
+    pub fn fetch_method<T: Methodical>(self, method: T) -> Result<Self> {
         if self.temporary.is_none() || self.remote.is_none() {
             return Err(Error::InsufficientArgumentsToDecide);
         }
@@ -153,17 +147,12 @@ impl Manager {
 
 /// For HashMap to implement string search
 pub trait Glubtastic {
-    fn globs<T>(&self, text: T) -> Vec<String>
-    where
-        T: AsRef<str>;
+    fn globs<T: AsRef<str>>(&self, text: T) -> Vec<String>;
 }
 
 impl Glubtastic for HashMap<String, String> {
     /// Catch all @variable@ references within a string
-    fn globs<T>(&self, text: T) -> Vec<String>
-    where
-        T: AsRef<str>,
-    {
+    fn globs<T: AsRef<str>>(&self, text: T) -> Vec<String> {
         REGEX
             .captures_iter(text.as_ref())
             .map(|caps| {

src/schemes/template/apply.rs

@@ -9,10 +9,7 @@ enum Instructions {
     Unknown,
 }
 
-impl<T> From<T> for Instructions
-where
-    T: ToString,
-{
+impl<T: ToString> From<T> for Instructions {
     fn from(value: T) -> Self {
         match value.to_string().to_lowercase().as_str() {
             "uppercase" => Self::Uppercase,
@@ -25,10 +22,7 @@ where
 pub struct Apply(Vec<Instructions>);
 
 impl Apply {
-    pub fn parse<T>(input: T) -> Apply
-    where
-        T: ToString,
-    {
+    pub fn parse<T: ToString>(input: T) -> Apply {
         Apply(
             input
                 .to_string()
@@ -38,10 +32,7 @@ impl Apply {
         )
     }
 
-    pub fn execute<T>(&self, input: T) -> String
-    where
-        T: ToString,
-    {
+    pub fn execute<T: ToString>(&self, input: T) -> String {
         self.0.iter().fold(
             input.to_string(),
             |current, instruction| match instruction {