Add doc examples

Author: MrGVSV

crates/bevy_app/src/app.rs

@@ -605,7 +605,59 @@ impl App {
 
     /// Registers the given function into the [`AppFunctionRegistry`] resource using the given name.
     ///
-    /// See [`bevy_reflect::func::FunctionRegistry::register`] for more information.
+    /// To avoid conflicts, it's recommended to use a unique name for the function.
+    /// This can be achieved by either using the function's [type name] or
+    /// by "namespacing" the function with a unique identifier,
+    /// such as the name of your crate.
+    ///
+    /// For example, to register a function, `add`, from a crate, `my_crate`,
+    /// you could use the name, `"my_crate::add"`.
+    ///
+    /// Only functions that implement [`IntoFunction`] may be registered via this method.
+    ///
+    /// See [`FunctionRegistry::register`] for more information.
+    ///
+    /// # Panics
+    ///
+    /// Panics if a function has already been registered with the given name.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bevy_app::App;
+    ///
+    /// fn yell(text: String) {
+    ///     println!("{}!", text);
+    /// }
+    ///
+    /// App::new()
+    ///     // Registering an anonymous function with a unique name
+    ///     .register_function("my_crate::yell_louder", |text: String| {
+    ///         println!("{}!!!", text.to_uppercase());
+    ///     })
+    ///     // Registering an existing function with its type name
+    ///     .register_function(std::any::type_name_of_val(&yell), yell)
+    ///     // Registering an existing function with a custom name
+    ///     .register_function("my_crate::yell", yell);
+    /// ```
+    ///
+    /// Names must be unique.
+    ///
+    /// ```should_panic
+    /// use bevy_app::App;
+    ///
+    /// fn one() {}
+    /// fn two() {}
+    ///
+    /// App::new()
+    ///     .register_function("my_function", one)
+    ///     // Panic! A function has already been registered with the name "my_function"
+    ///     .register_function("my_function", two);
+    /// ```
+    ///
+    /// [type name]: std::any::type_name
+    /// [`IntoFunction`]: bevy_reflect::func::IntoFunction
+    /// [`FunctionRegistry`]: bevy_reflect::func::FunctionRegistry::register
     #[cfg(feature = "reflect_functions")]
     pub fn register_function<F, Marker>(
         &mut self,

crates/bevy_reflect/src/func/registry.rs

@@ -45,6 +45,43 @@ impl FunctionRegistry {
     /// This method is a convenience around calling [`IntoFunction::into_function`] and [`DynamicFunction::with_name`]
     /// on the function and inserting it into the registry using the [`register_dynamic`] method.
     ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bevy_reflect::func::{FunctionRegistrationError, FunctionRegistry};
+    /// fn mul(a: i32, b: i32) -> i32 {
+    ///     a * b
+    /// }
+    ///
+    /// # fn main() -> Result<(), FunctionRegistrationError> {
+    /// let mut registry = FunctionRegistry::default();
+    /// registry
+    ///   // Registering an anonymous function with a unique name
+    ///   .register("my_crate::add", |a: i32, b: i32| {
+    ///     a + b
+    ///   })?
+    ///   // Registering an existing function with its type name
+    ///   .register(std::any::type_name_of_val(&mul), mul)?
+    ///   // Registering an existing function with a custom name
+    ///   .register("my_crate::mul", mul)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Names must be unique.
+    ///
+    /// ```should_panic
+    /// # use bevy_reflect::func::FunctionRegistry;
+    /// fn one() {}
+    /// fn two() {}
+    ///
+    /// let mut registry = FunctionRegistry::default();
+    /// registry.register("my_function", one).unwrap();
+    ///
+    /// // Panic! A function has already been registered with the name "my_function"
+    /// registry.register("my_function", two).unwrap();
+    /// ```
+    ///
     /// [name]: DynamicFunction::name
     /// [`overwrite_registration`]: Self::overwrite_registration
     /// [type name]: std::any::type_name
@@ -70,6 +107,42 @@ impl FunctionRegistry {
     ///
     /// You can change the name of the function using [`DynamicFunction::with_name`].
     ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bevy_reflect::func::{DynamicFunction, FunctionRegistrationError, FunctionRegistry, IntoFunction};
+    /// fn add(a: i32, b: i32) -> i32 {
+    ///   a + b
+    /// }
+    ///
+    /// # fn main() -> Result<(), FunctionRegistrationError> {
+    /// let mut registry = FunctionRegistry::default();
+    ///
+    /// // Register a `DynamicFunction` directly
+    /// let function: DynamicFunction = add.into_function();
+    /// registry.register_dynamic(function)?;
+    ///
+    /// // Register a `DynamicFunction` with a custom name
+    /// let function: DynamicFunction = add.into_function().with_name("my_crate::add");
+    /// registry.register_dynamic(function)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Names must be unique.
+    ///
+    /// ```should_panic
+    /// # use bevy_reflect::func::{DynamicFunction, FunctionRegistry, IntoFunction};
+    /// fn one() {}
+    /// fn two() {}
+    ///
+    /// let mut registry = FunctionRegistry::default();
+    /// registry.register_dynamic(one.into_function().with_name("my_function")).unwrap();
+    ///
+    /// // Panic! A function has already been registered with the name "my_function"
+    /// registry.register_dynamic(two.into_function().with_name("my_function")).unwrap();
+    /// ```
+    ///
     /// [name]: DynamicFunction::name
     /// [`overwrite_registration_dynamic`]: Self::overwrite_registration_dynamic
     pub fn register_dynamic(