Make the math commands const (#13566)

This PR closes [Issue
#13482](https://github.com/nushell/nushell/issues/13482)

# Description
This PR tend to make all math function to be constant. 

# User-Facing Changes
The math commands now can be used as constant methods.

### Some Example
```
> const MODE = [3 3 9 12 12 15] | math mode
> $MODE
╭───┬────╮
│ 0 │  3 │
│ 1 │ 12 │
╰───┴────╯

> const LOG = [16 8 4] | math log 2
> $LOG
╭───┬──────╮
│ 0 │ 4.00 │
│ 1 │ 3.00 │
│ 2 │ 2.00 │
╰───┴──────╯

> const VAR = [1 3 5] | math variance
> $VAR
2.6666666666666665
```

# Tests + Formatting
Tests are added for all of the math command to test there constant
behavior.

I mostly focused on the actual user experience, not the correctness of
the methods and algorithms.

# After Submitting
I think this change don't require any additional documentation. Feel
free to correct me in this topic please.

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

@@ -34,6 +34,10 @@ impl Command for SubCommand {
         vec!["absolute", "modulus", "positive", "distance"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -45,6 +49,19 @@ impl Command for SubCommand {
         input.map(move |value| abs_helper(value, head), engine_state.signals())
     }
 
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        input.map(
+            move |value| abs_helper(value, head),
+            working_set.permanent().signals(),
+        )
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Compute absolute value of each number in a list of numbers",

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

@@ -38,6 +38,10 @@ impl Command for SubCommand {
         vec!["average", "mean", "statistics"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -48,6 +52,15 @@ impl Command for SubCommand {
         run_with_function(call, input, average)
     }
 
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        run_with_function(call, input, average)
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -29,6 +29,10 @@ impl Command for SubCommand {
         vec!["ceiling", "round up", "rounding", "integer"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -44,6 +48,23 @@ impl Command for SubCommand {
         input.map(move |value| operate(value, head), engine_state.signals())
     }
 
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head),
+            working_set.permanent().signals(),
+        )
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Apply the ceil function to a list of numbers",

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

@@ -29,6 +29,10 @@ impl Command for SubCommand {
         vec!["round down", "rounding", "integer"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -44,6 +48,23 @@ impl Command for SubCommand {
         input.map(move |value| operate(value, head), engine_state.signals())
     }
 
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head),
+            working_set.permanent().signals(),
+        )
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Apply the floor function to a list of numbers",

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

@@ -34,6 +34,10 @@ impl Command for SubCommand {
         vec!["base", "exponent", "inverse", "euler"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -63,6 +67,34 @@ impl Command for SubCommand {
         )
     }
 
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        let base: Spanned<f64> = call.req_const(working_set, 0)?;
+
+        if base.item <= 0.0f64 {
+            return Err(ShellError::UnsupportedInput {
+                msg: "Base has to be greater 0".into(),
+                input: "value originates from here".into(),
+                msg_span: head,
+                input_span: base.span,
+            });
+        }
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        let base = base.item;
+        input.map(
+            move |value| operate(value, head, base),
+            working_set.permanent().signals(),
+        )
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -35,6 +35,10 @@ impl Command for SubCommand {
         vec!["maximum", "largest"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -45,6 +49,15 @@ impl Command for SubCommand {
         run_with_function(call, input, maximum)
     }
 
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        run_with_function(call, input, maximum)
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -32,6 +32,10 @@ impl Command for SubCommand {
         vec!["middle", "statistics"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -42,6 +46,15 @@ impl Command for SubCommand {
         run_with_function(call, input, median)
     }
 
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        run_with_function(call, input, median)
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -35,6 +35,10 @@ impl Command for SubCommand {
         vec!["minimum", "smallest"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -45,6 +49,15 @@ impl Command for SubCommand {
         run_with_function(call, input, minimum)
     }
 
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        run_with_function(call, input, minimum)
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -62,6 +62,10 @@ impl Command for SubCommand {
         vec!["common", "often"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -72,6 +76,15 @@ impl Command for SubCommand {
         run_with_function(call, input, mode)
     }
 
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        run_with_function(call, input, mode)
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -32,6 +32,10 @@ impl Command for SubCommand {
         vec!["times", "multiply", "x", "*"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -42,6 +46,15 @@ impl Command for SubCommand {
         run_with_function(call, input, product)
     }
 
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        run_with_function(call, input, product)
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -35,6 +35,10 @@ impl Command for SubCommand {
         vec!["approx", "closest", "nearest"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -54,6 +58,24 @@ impl Command for SubCommand {
         )
     }
 
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let precision_param: Option<i64> = call.get_flag_const(working_set, "precision")?;
+        let head = call.head;
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head, precision_param),
+            working_set.permanent().signals(),
+        )
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -41,6 +41,10 @@ impl Command for SubCommand {
         ]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -52,6 +56,16 @@ impl Command for SubCommand {
         run_with_function(call, input, compute_stddev(sample))
     }
 
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let sample = call.has_flag_const(working_set, "sample")?;
+        run_with_function(call, input, compute_stddev(sample))
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -34,6 +34,10 @@ impl Command for SubCommand {
         vec!["plus", "add", "total", "+"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -44,6 +48,15 @@ impl Command for SubCommand {
         run_with_function(call, input, summation)
     }
 
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        run_with_function(call, input, summation)
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

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

@@ -33,6 +33,10 @@ impl Command for SubCommand {
         vec!["deviation", "dispersion", "variation", "statistics"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -44,6 +48,16 @@ impl Command for SubCommand {
         run_with_function(call, input, compute_variance(sample))
     }
 
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let sample = call.has_flag_const(working_set, "sample")?;
+        run_with_function(call, input, compute_variance(sample))
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {