Rework operator type errors (#14429)

# Description

This PR adds two new `ParseError` and `ShellError` cases for type errors
relating to operators.
- `OperatorUnsupportedType` is used when a type is not supported by an
operator in any way, shape, or form. E.g., `+` does not support `bool`.
- `OperatorIncompatibleTypes` is used when a operator is used with types
it supports, but the combination of types provided cannot be used
together. E.g., `filesize + duration` is not a valid combination.

The other preexisting error cases related to operators have been removed
and replaced with the new ones above. Namely:

- `ShellError::OperatorMismatch`
- `ShellError::UnsupportedOperator`
- `ParseError::UnsupportedOperationLHS`
- `ParseError::UnsupportedOperationRHS`
- `ParseError::UnsupportedOperationTernary`

# User-Facing Changes

- `help operators` now lists the precedence of `not` as 55 instead of 0
(above the other boolean operators). Fixes #13675.
- `math median` and `math mode` now ignore NaN values so that `[NaN NaN]
| math median` and `[NaN NaN] | math mode` no longer trigger a type
error. Instead, it's now an empty input error. Fixing this in earnest
can be left for a future PR.
- Comparisons with `nan` now return false instead of causing an error.
E.g., `1 == nan` is now `false`.
- All the operator type errors have been standardized and reworked. In
particular, they can now have a help message, which is currently used
for types errors relating to `++`.

```nu
[1] ++ 2
```
```
Error: nu::parser::operator_unsupported_type

  × The '++' operator does not work on values of type 'int'.
   ╭─[entry #1:1:5]
 1 │ [1] ++ 2
   ·     ─┬ ┬
   ·      │ ╰── int
   ·      ╰── does not support 'int'
   ╰────
  help: if you meant to append a value to a list or a record to a table, use the `append` command or wrap the value in a list. For example: `$list ++ $value` should be
        `$list ++ [$value]` or `$list | append $value`.
```

crates/nu-command/src/math/median.rs

@@ -91,45 +91,26 @@ pub fn median(values: &[Value], span: Span, head: Span) -> Result<Value, ShellEr
         Pick::Median
     };
 
-    let mut sorted = vec![];
-
-    for item in values {
-        sorted.push(item.clone());
-    }
-
-    if let Some(Err(values)) = values
-        .windows(2)
-        .map(|elem| {
-            if elem[0].partial_cmp(&elem[1]).is_none() {
-                return Err(ShellError::OperatorMismatch {
-                    op_span: head,
-                    lhs_ty: elem[0].get_type().to_string(),
-                    lhs_span: elem[0].span(),
-                    rhs_ty: elem[1].get_type().to_string(),
-                    rhs_span: elem[1].span(),
-                });
-            }
-            Ok(elem[0].partial_cmp(&elem[1]).unwrap_or(Ordering::Equal))
-        })
-        .find(|elem| elem.is_err())
-    {
-        return Err(values);
-    }
+    let mut sorted = values
+        .iter()
+        .filter(|x| !x.as_float().is_ok_and(f64::is_nan))
+        .collect::<Vec<_>>();
 
     sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
 
     match take {
         Pick::Median => {
             let idx = (values.len() as f64 / 2.0).floor() as usize;
-            let out = sorted
+            Ok(sorted
                 .get(idx)
                 .ok_or_else(|| ShellError::UnsupportedInput {
                     msg: "Empty input".to_string(),
                     input: "value originates from here".into(),
                     msg_span: head,
                     input_span: span,
-                })?;
-            Ok(out.clone())
+                })?
+                .to_owned()
+                .to_owned())
         }
         Pick::MedianAverage => {
             let idx_end = values.len() / 2;
@@ -143,7 +124,8 @@ pub fn median(values: &[Value], span: Span, head: Span) -> Result<Value, ShellEr
                     msg_span: head,
                     input_span: span,
                 })?
-                .clone();
+                .to_owned()
+                .to_owned();
 
             let right = sorted
                 .get(idx_end)
@@ -153,7 +135,8 @@ pub fn median(values: &[Value], span: Span, head: Span) -> Result<Value, ShellEr
                     msg_span: head,
                     input_span: span,
                 })?
-                .clone();
+                .to_owned()
+                .to_owned();
 
             average(&[left, right], span, head)
         }

crates/nu-command/src/math/mode.rs

@@ -111,29 +111,12 @@ impl Command for SubCommand {
 }
 
 pub fn mode(values: &[Value], _span: Span, head: Span) -> Result<Value, ShellError> {
-    if let Some(Err(values)) = values
-        .windows(2)
-        .map(|elem| {
-            if elem[0].partial_cmp(&elem[1]).is_none() {
-                return Err(ShellError::OperatorMismatch {
-                    op_span: head,
-                    lhs_ty: elem[0].get_type().to_string(),
-                    lhs_span: elem[0].span(),
-                    rhs_ty: elem[1].get_type().to_string(),
-                    rhs_span: elem[1].span(),
-                });
-            }
-            Ok(elem[0].partial_cmp(&elem[1]).unwrap_or(Ordering::Equal))
-        })
-        .find(|elem| elem.is_err())
-    {
-        return Err(values);
-    }
     //In e-q, Value doesn't implement Hash or Eq, so we have to get the values inside
     // But f64 doesn't implement Hash, so we get the binary representation to use as
     // key in the HashMap
     let hashable_values = values
         .iter()
+        .filter(|x| !x.as_float().is_ok_and(f64::is_nan))
         .map(|val| match val {
             Value::Int { val, .. } => Ok(HashableType::new(val.to_ne_bytes(), NumberTypes::Int)),
             Value::Duration { val, .. } => {

crates/nu-command/src/math/reducers.rs

@@ -32,18 +32,8 @@ pub fn max(data: Vec<Value>, span: Span, head: Span) -> Result<Value, ShellError
         .clone();
 
     for value in &data {
-        if let Some(result) = value.partial_cmp(&biggest) {
-            if result == Ordering::Greater {
-                biggest = value.clone();
-            }
-        } else {
-            return Err(ShellError::OperatorMismatch {
-                op_span: head,
-                lhs_ty: biggest.get_type().to_string(),
-                lhs_span: biggest.span(),
-                rhs_ty: value.get_type().to_string(),
-                rhs_span: value.span(),
-            });
+        if value.partial_cmp(&biggest) == Some(Ordering::Greater) {
+            biggest = value.clone();
         }
     }
     Ok(biggest)
@@ -61,18 +51,8 @@ pub fn min(data: Vec<Value>, span: Span, head: Span) -> Result<Value, ShellError
         .clone();
 
     for value in &data {
-        if let Some(result) = value.partial_cmp(&smallest) {
-            if result == Ordering::Less {
-                smallest = value.clone();
-            }
-        } else {
-            return Err(ShellError::OperatorMismatch {
-                op_span: head,
-                lhs_ty: smallest.get_type().to_string(),
-                lhs_span: smallest.span(),
-                rhs_ty: value.get_type().to_string(),
-                rhs_span: value.span(),
-            });
+        if value.partial_cmp(&smallest) == Some(Ordering::Less) {
+            smallest = value.clone();
         }
     }
     Ok(smallest)