Add `join` function

CHANGELOG.md

···
 - Function `eq` to compare two values for equality.
 - Function `format` to format strings.
 - Function `concat` to concatenate lists.
+- Function `join` to join a list of values using an optional separator.
 
 #### Removed
 

src/functions.rs

···
         // list functions
         functions.add(Identifier::from("concat"), stdlib::list::Concat);
         functions.add(Identifier::from("is-empty"), stdlib::list::IsEmpty);
+        functions.add(Identifier::from("join"), stdlib::list::Join);
         functions.add(Identifier::from("length"), stdlib::list::Length);
         functions
     }
···
             ) -> Result<Value, ExecutionError> {
                 let list = parameters.param()?.into_list()?;
                 Ok(list.is_empty().into())
+            }
+        }
+
+        /// The implementation of the standard [`join`][`crate::reference::functions#join`] function.
+        pub struct Join;
+
+        impl Function for Join {
+            fn call(
+                &self,
+                _graph: &mut Graph,
+                _source: &str,
+                parameters: &mut dyn Parameters,
+            ) -> Result<Value, ExecutionError> {
+                let list = parameters.param()?.into_list()?;
+                let sep = match parameters.param() {
+                    Ok(sep) => sep.into_string()?,
+                    Err(_) => "".to_string(),
+                };
+                parameters.finish()?;
+                let result = list
+                    .into_iter()
+                    .map(|x| format!("{}", x))
+                    .collect::<Vec<_>>()
+                    .join(&sep);
+                Ok(result.into())
             }
         }
 

src/reference/functions.rs

···
 //!   - Input parameters: a list value
 //!   - Output value: a boolean indicating whether the list is empty or not
 //!
+//! ## `join`
+//!
+//! Join a list of values using the given separator
+//!
+//!  - Input parameters:
+//!    - `list`: A list of values
+//!    - `sep`: An optional separator string
+//! - Output value:
+//!   - A string consisting of the formatted values from the list separated by
+//!     the separator string
+//!
 //! ## `length`
 //!
 //! Determine the length of a list.

tests/it/functions.rs

···
         "#},
     );
 }
+
+#[test]
+fn can_join_list_with_separator() {
+    check_execution(
+        "pass",
+        indoc! {r#"
+          (module) @root
+          {
+            node n
+            attr (n) str = (join [1, 2, 3] ".")
+          }
+        "#},
+        indoc! {r#"
+          node 0
+            str: "1.2.3"
+        "#},
+    );
+}
+
+#[test]
+fn can_join_list_without_separator() {
+    check_execution(
+        "pass",
+        indoc! {r#"
+          (module) @root
+          {
+            node n
+            attr (n) str = (join [1, 2, 3])
+          }
+        "#},
+        indoc! {r#"
+          node 0
+            str: "123"
+        "#},
+    );
+}