Attempts to add // math operator (#5759)

* attempts to add `div` math operator

* allows `//` to be used too

* fmt:

* clippy issue

* returns appropriate type

* returns appropriate type 2

* fmt

* ensure consistency; rename to `fdiv`

* Update parser.rs

crates/nu-command/src/database/values/dsl/expression.rs

@@ -112,6 +112,7 @@ impl CustomValue for ExprDb {
             Operator::Multiply => Ok(BinaryOperator::Multiply),
             Operator::Divide => Ok(BinaryOperator::Divide),
             Operator::Modulo => Ok(BinaryOperator::Modulo),
+            Operator::FloorDivision => Ok(BinaryOperator::Divide),
             Operator::And => Ok(BinaryOperator::And),
             Operator::Or => Ok(BinaryOperator::Or),
             Operator::In

crates/nu-command/src/dataframe/values/nu_expression/custom_value.rs

@@ -100,6 +100,7 @@ fn with_operator(
         Operator::Multiply => apply_arithmetic(left, right, lhs_span, Mul::mul),
         Operator::Divide => apply_arithmetic(left, right, lhs_span, Div::div),
         Operator::Modulo => apply_arithmetic(left, right, lhs_span, Rem::rem),
+        Operator::FloorDivision => apply_arithmetic(left, right, lhs_span, Div::div),
         Operator::Equal => Ok(left
             .clone()
             .apply_with_expr(right.clone(), Expr::eq)

crates/nu-command/tests/commands/math/mod.rs

@@ -163,6 +163,89 @@ fn error_zero_division_decimal_decimal() {
     assert!(actual.err.contains("division by zero"));
 }
 
+#[test]
+fn floor_division_of_ints() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            5 // 2
+        "#
+    ));
+
+    assert_eq!(actual.out, "2");
+}
+
+#[test]
+fn floor_division_of_ints2() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            -3 // 2
+        "#
+    ));
+
+    assert_eq!(actual.out, "-2");
+}
+
+#[test]
+fn floor_division_of_floats() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            -3.0 // 2.0
+        "#
+    ));
+
+    assert_eq!(actual.out, "-2");
+}
+
+#[test]
+fn error_zero_floor_division_int_int() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 // 0
+        "#
+    ));
+
+    assert!(actual.err.contains("division by zero"));
+}
+
+#[test]
+fn error_zero_floor_division_decimal_int() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1.0 // 0
+        "#
+    ));
+
+    assert!(actual.err.contains("division by zero"));
+}
+
+#[test]
+fn error_zero_floor_division_int_decimal() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 // 0.0
+        "#
+    ));
+
+    assert!(actual.err.contains("division by zero"));
+}
+
+#[test]
+fn error_zero_floor_division_decimal_decimal() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1.0 // 0.0
+        "#
+    ));
+
+    assert!(actual.err.contains("division by zero"));
+}
 #[test]
 fn proper_precedence_history() {
     let actual = nu!(