From cf8c922704a38980def3c6267cee2eeba304394c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Moritz=20H=C3=B6lting?=
 <87192362+moritz-hoelting@users.noreply.github.com>
Date: Fri, 7 Mar 2025 16:45:36 +0100
Subject: [PATCH] change function parameter types from &str to impl
 Into<String> if converted to string anyways

---
 src/datapack/function.rs  |  6 +++---
 src/datapack/mod.rs       | 23 ++++++++++++-----------
 src/datapack/namespace.rs | 17 +++++++++--------
 3 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/src/datapack/function.rs b/src/datapack/function.rs
index e5d627c..637f0e0 100644
--- a/src/datapack/function.rs
+++ b/src/datapack/function.rs
@@ -25,11 +25,11 @@ pub struct Function {
 }
 
 impl Function {
-    pub(in crate::datapack) fn new(namespace: &str, name: &str) -> Self {
+    pub(in crate::datapack) fn new(namespace: impl Into<String>, name: impl Into<String>) -> Self {
         Self {
             commands: Vec::new(),
-            name: name.to_string(),
-            namespace: namespace.to_string(),
+            name: name.into(),
+            namespace: namespace.into(),
         }
     }
     /// Add a command to the function.
diff --git a/src/datapack/mod.rs b/src/datapack/mod.rs
index 645f6d6..a1b1060 100644
--- a/src/datapack/mod.rs
+++ b/src/datapack/mod.rs
@@ -95,36 +95,37 @@ impl Datapack {
     }
 
     /// Mutably get a namespace by name or create a new one if it doesn't exist.
-    pub fn namespace_mut(&mut self, name: &str) -> &mut Namespace {
+    pub fn namespace_mut(&mut self, name: impl Into<String>) -> &mut Namespace {
+        let name = name.into();
         self.namespaces
-            .entry(name.to_string())
+            .entry(name.clone())
             .or_insert_with(|| Namespace::new(name))
     }
 
     /// Add a function to the tick function list.
-    pub fn add_tick(&mut self, function: &str) {
+    pub fn add_tick(&mut self, function: impl Into<String>) {
         self.namespace_mut("minecraft")
             .tag_mut("tick", tag::TagType::Function)
-            .add_value(tag::TagValue::Simple(function.to_string()));
+            .add_value(tag::TagValue::Simple(function.into()));
     }
 
     /// Add a function to the load function list.
-    pub fn add_load(&mut self, function: &str) {
+    pub fn add_load(&mut self, function: impl Into<String>) {
         self.namespace_mut("minecraft")
             .tag_mut("load", tag::TagType::Function)
-            .add_value(tag::TagValue::Simple(function.to_string()));
+            .add_value(tag::TagValue::Simple(function.into()));
     }
 
     /// Register a scoreboard.
     pub fn register_scoreboard(
         &mut self,
-        name: &str,
-        criteria: Option<&str>,
-        display_name: Option<&str>,
+        name: impl Into<String>,
+        criteria: Option<impl Into<String>>,
+        display_name: Option<impl Into<String>>,
     ) {
         self.scoreboards.insert(
-            name.to_string(),
-            (criteria.map(String::from), display_name.map(String::from)),
+            name.into(),
+            (criteria.map(Into::into), display_name.map(Into::into)),
         );
     }
 
diff --git a/src/datapack/namespace.rs b/src/datapack/namespace.rs
index 99f53c3..aa2e295 100644
--- a/src/datapack/namespace.rs
+++ b/src/datapack/namespace.rs
@@ -28,9 +28,9 @@ pub struct Namespace {
 
 impl Namespace {
     /// Create a new namespace.
-    pub(in crate::datapack) fn new(name: &str) -> Self {
+    pub(in crate::datapack) fn new(name: impl Into<String>) -> Self {
         Self {
-            name: name.to_string(),
+            name: name.into(),
             functions: HashMap::new(),
             tags: HashMap::new(),
         }
@@ -62,23 +62,24 @@ impl Namespace {
 
     /// Mutably get a function by name or create a new one if it doesn't exist.
     #[must_use]
-    pub fn function_mut(&mut self, name: &str) -> &mut Function {
+    pub fn function_mut(&mut self, name: impl Into<String>) -> &mut Function {
+        let name = name.into();
         self.functions
-            .entry(name.to_string())
+            .entry(name.clone())
             .or_insert_with(|| Function::new(&self.name, name))
     }
 
     /// Get a tag by name and type.
     #[must_use]
-    pub fn tag(&self, name: &str, tag_type: TagType) -> Option<&Tag> {
-        self.tags.get(&(name.to_string(), tag_type))
+    pub fn tag(&self, name: impl Into<String>, tag_type: TagType) -> Option<&Tag> {
+        self.tags.get(&(name.into(), tag_type))
     }
 
     /// Mutably get a tag by name and type or create a new one if it doesn't exist.
     #[must_use]
-    pub fn tag_mut(&mut self, name: &str, tag_type: TagType) -> &mut Tag {
+    pub fn tag_mut(&mut self, name: impl Into<String>, tag_type: TagType) -> &mut Tag {
         self.tags
-            .entry((name.to_string(), tag_type))
+            .entry((name.into(), tag_type))
             .or_insert_with(|| Tag::new(false))
     }