diff --git a/crates/nu-command/src/conversions/into/decimal.rs b/crates/nu-command/src/conversions/into/decimal.rs index 641eb4963b..5c4e13d9e2 100644 --- a/crates/nu-command/src/conversions/into/decimal.rs +++ b/crates/nu-command/src/conversions/into/decimal.rs @@ -38,7 +38,11 @@ impl Command for SubCommand { } fn usage(&self) -> &str { - "Convert text into a decimal." + "deprecated: convert data into a floating point number." + } + + fn extra_usage(&self) -> &str { + "Use `into float` instead" } fn search_terms(&self) -> Vec<&str> { @@ -52,6 +56,16 @@ impl Command for SubCommand { call: &Call, input: PipelineData, ) -> Result { + nu_protocol::report_error_new( + engine_state, + &ShellError::GenericError( + "Deprecated command".into(), + "`into decimal` is deprecated and will be removed in 0.86.".into(), + Some(call.head), + Some("Use `into float` instead".into()), + vec![], + ), + ); let cell_paths: Vec = call.rest(engine_state, stack, 0)?; let args = CellPathOnlyArgs::from(cell_paths); operate(action, args, input, call.head, engine_state.ctrlc.clone()) @@ -60,7 +74,7 @@ impl Command for SubCommand { fn examples(&self) -> Vec { vec![ Example { - description: "Convert string to decimal in table", + description: "Convert string to float in table", example: "[[num]; ['5.01']] | into decimal num", result: Some(Value::list( vec![Value::test_record(Record { @@ -71,7 +85,7 @@ impl Command for SubCommand { )), }, Example { - description: "Convert string to decimal", + description: "Convert string to float", example: "'1.345' | into decimal", result: Some(Value::test_float(1.345)), }, @@ -84,7 +98,7 @@ impl Command for SubCommand { ])), }, Example { - description: "Convert boolean to decimal", + description: "Convert boolean to float", example: "true | into decimal", result: Some(Value::test_float(1.0)), }, diff --git a/crates/nu-command/src/conversions/into/float.rs b/crates/nu-command/src/conversions/into/float.rs new file mode 100644 index 0000000000..7ccab4017e --- /dev/null +++ b/crates/nu-command/src/conversions/into/float.rs @@ -0,0 +1,181 @@ +use nu_cmd_base::input_handler::{operate, CellPathOnlyArgs}; +use nu_engine::CallExt; +use nu_protocol::{ + ast::{Call, CellPath}, + engine::{Command, EngineState, Stack}, + Category, Example, PipelineData, Record, ShellError, Signature, Span, SyntaxShape, Type, Value, +}; + +#[derive(Clone)] +pub struct SubCommand; + +impl Command for SubCommand { + fn name(&self) -> &str { + "into float" + } + + fn signature(&self) -> Signature { + Signature::build("into float") + .input_output_types(vec![ + (Type::Int, Type::Float), + (Type::String, Type::Float), + (Type::Bool, Type::Float), + (Type::Float, Type::Float), + (Type::Table(vec![]), Type::Table(vec![])), + (Type::Record(vec![]), Type::Record(vec![])), + ( + Type::List(Box::new(Type::Any)), + Type::List(Box::new(Type::Float)), + ), + ]) + .rest( + "rest", + SyntaxShape::CellPath, + "for a data structure input, convert data at the given cell paths", + ) + .allow_variants_without_examples(true) + .category(Category::Conversions) + } + + fn usage(&self) -> &str { + "Convert data into floating point number." + } + + fn search_terms(&self) -> Vec<&str> { + vec!["convert", "number", "floating", "decimal"] + } + + fn run( + &self, + engine_state: &EngineState, + stack: &mut Stack, + call: &Call, + input: PipelineData, + ) -> Result { + let cell_paths: Vec = call.rest(engine_state, stack, 0)?; + let args = CellPathOnlyArgs::from(cell_paths); + operate(action, args, input, call.head, engine_state.ctrlc.clone()) + } + + fn examples(&self) -> Vec { + vec![ + Example { + description: "Convert string to float in table", + example: "[[num]; ['5.01']] | into float num", + result: Some(Value::test_list(vec![Value::test_record(Record { + cols: vec!["num".to_string()], + vals: vec![Value::test_float(5.01)], + })])), + }, + Example { + description: "Convert string to floating point number", + example: "'1.345' | into float", + result: Some(Value::test_float(1.345)), + }, + Example { + description: "Coerce list of ints and floats to float", + example: "[4 -5.9] | into float", + result: Some(Value::test_list(vec![ + Value::test_float(4.0), + Value::test_float(-5.9), + ])), + }, + Example { + description: "Convert boolean to float", + example: "true | into float", + result: Some(Value::test_float(1.0)), + }, + ] + } +} + +fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value { + let span = input.span(); + match input { + Value::Float { .. } => input.clone(), + Value::String { val: s, .. } => { + let other = s.trim(); + + match other.parse::() { + Ok(x) => Value::float(x, head), + Err(reason) => Value::error( + ShellError::CantConvert { + to_type: "float".to_string(), + from_type: reason.to_string(), + span, + help: None, + }, + span, + ), + } + } + Value::Int { val: v, .. } => Value::float(*v as f64, span), + Value::Bool { val: b, .. } => Value::float( + match b { + true => 1.0, + false => 0.0, + }, + span, + ), + // Propagate errors by explicitly matching them before the final case. + Value::Error { .. } => input.clone(), + other => Value::error( + ShellError::OnlySupportsThisInputType { + exp_input_type: "string, integer or bool".into(), + wrong_type: other.get_type().to_string(), + dst_span: head, + src_span: other.span(), + }, + head, + ), + } +} + +#[cfg(test)] +mod tests { + use super::*; + use nu_protocol::Type::Error; + + #[test] + fn test_examples() { + use crate::test_examples; + + test_examples(SubCommand {}) + } + + #[test] + #[allow(clippy::approx_constant)] + fn string_to_decimal() { + let word = Value::test_string("3.1415"); + let expected = Value::test_float(3.1415); + + let actual = action(&word, &CellPathOnlyArgs::from(vec![]), Span::test_data()); + assert_eq!(actual, expected); + } + + #[test] + fn communicates_parsing_error_given_an_invalid_decimallike_string() { + let invalid_str = Value::test_string("11.6anra"); + + let actual = action( + &invalid_str, + &CellPathOnlyArgs::from(vec![]), + Span::test_data(), + ); + + assert_eq!(actual.get_type(), Error); + } + + #[test] + fn int_to_float() { + let input_int = Value::test_int(10); + let expected = Value::test_float(10.0); + let actual = action( + &input_int, + &CellPathOnlyArgs::from(vec![]), + Span::test_data(), + ); + + assert_eq!(actual, expected); + } +} diff --git a/crates/nu-command/src/conversions/into/mod.rs b/crates/nu-command/src/conversions/into/mod.rs index ee0ad71d5c..9f0f27962a 100644 --- a/crates/nu-command/src/conversions/into/mod.rs +++ b/crates/nu-command/src/conversions/into/mod.rs @@ -5,6 +5,7 @@ mod datetime; mod decimal; mod duration; mod filesize; +mod float; mod int; mod record; mod string; @@ -16,6 +17,7 @@ pub use command::Into; pub use datetime::SubCommand as IntoDatetime; pub use decimal::SubCommand as IntoDecimal; pub use duration::SubCommand as IntoDuration; +pub use float::SubCommand as IntoFloat; pub use int::SubCommand as IntoInt; pub use record::SubCommand as IntoRecord; pub use string::SubCommand as IntoString; diff --git a/crates/nu-command/src/default_context.rs b/crates/nu-command/src/default_context.rs index 0ff540dd83..bd73636d11 100644 --- a/crates/nu-command/src/default_context.rs +++ b/crates/nu-command/src/default_context.rs @@ -288,6 +288,7 @@ pub fn add_shell_command_context(mut engine_state: EngineState) -> EngineState { IntoDatetime, IntoDecimal, IntoDuration, + IntoFloat, IntoFilesize, IntoInt, IntoRecord, diff --git a/crates/nu-command/tests/commands/str_/mod.rs b/crates/nu-command/tests/commands/str_/mod.rs index eb54883b83..710da25801 100644 --- a/crates/nu-command/tests/commands/str_/mod.rs +++ b/crates/nu-command/tests/commands/str_/mod.rs @@ -140,7 +140,7 @@ fn converts_to_decimal() { r#" echo "3.1, 0.0415" | split row "," - | into decimal + | into float | math sum "# )); diff --git a/crates/nu-protocol/src/value/mod.rs b/crates/nu-protocol/src/value/mod.rs index ee3247f23f..4338b5f764 100644 --- a/crates/nu-protocol/src/value/mod.rs +++ b/crates/nu-protocol/src/value/mod.rs @@ -2426,7 +2426,7 @@ impl Value { if let Some(val) = lhs.checked_add(*rhs) { Ok(Value::int(val, span)) } else { - Err(ShellError::OperatorOverflow { msg: "add operation overflowed".into(), span, help: "Consider using floating point values for increased range by promoting operand with 'into decimal'. Note: float has reduced precision!".into() }) + Err(ShellError::OperatorOverflow { msg: "add operation overflowed".into(), span, help: "Consider using floating point values for increased range by promoting operand with 'into float'. Note: float has reduced precision!".into() }) } } (Value::Int { val: lhs, .. }, Value::Float { val: rhs, .. }) => { @@ -2532,7 +2532,7 @@ impl Value { if let Some(val) = lhs.checked_sub(*rhs) { Ok(Value::int(val, span)) } else { - Err(ShellError::OperatorOverflow { msg: "subtraction operation overflowed".into(), span, help: "Consider using floating point values for increased range by promoting operand with 'into decimal'. Note: float has reduced precision!".into() }) + Err(ShellError::OperatorOverflow { msg: "subtraction operation overflowed".into(), span, help: "Consider using floating point values for increased range by promoting operand with 'into float'. Note: float has reduced precision!".into() }) } } (Value::Int { val: lhs, .. }, Value::Float { val: rhs, .. }) => { @@ -2610,7 +2610,7 @@ impl Value { if let Some(val) = lhs.checked_mul(*rhs) { Ok(Value::int(val, span)) } else { - Err(ShellError::OperatorOverflow { msg: "multiply operation overflowed".into(), span, help: "Consider using floating point values for increased range by promoting operand with 'into decimal'. Note: float has reduced precision!".into() }) + Err(ShellError::OperatorOverflow { msg: "multiply operation overflowed".into(), span, help: "Consider using floating point values for increased range by promoting operand with 'into float'. Note: float has reduced precision!".into() }) } } (Value::Int { val: lhs, .. }, Value::Float { val: rhs, .. }) => { @@ -3547,7 +3547,7 @@ impl Value { if let Some(val) = lhs.checked_pow(*rhs as u32) { Ok(Value::int(val, span)) } else { - Err(ShellError::OperatorOverflow { msg: "pow operation overflowed".into(), span, help: "Consider using floating point values for increased range by promoting operand with 'into decimal'. Note: float has reduced precision!".into() }) + Err(ShellError::OperatorOverflow { msg: "pow operation overflowed".into(), span, help: "Consider using floating point values for increased range by promoting operand with 'into float'. Note: float has reduced precision!".into() }) } } (Value::Int { val: lhs, .. }, Value::Float { val: rhs, .. }) => { diff --git a/crates/nu-std/std/mod.nu b/crates/nu-std/std/mod.nu index b0ec84d134..9ac30ec869 100644 --- a/crates/nu-std/std/mod.nu +++ b/crates/nu-std/std/mod.nu @@ -247,7 +247,7 @@ export def bench [ let times = ( seq 1 $rounds | each {|i| if $verbose { print -n $"($i) / ($rounds)\r" } - timeit { do $code } | into int | into decimal + timeit { do $code } | into int | into float } ) diff --git a/crates/nu-std/tests/test_asserts.nu b/crates/nu-std/tests/test_asserts.nu index 7311b7979d..b155022473 100644 --- a/crates/nu-std/tests/test_asserts.nu +++ b/crates/nu-std/tests/test_asserts.nu @@ -19,7 +19,7 @@ def assert_not [] { #[test] def assert_equal [] { assert equal (1 + 2) 3 - assert equal (0.1 + 0.2 | into string | into decimal) 0.3 # 0.30000000000000004 == 0.3 + assert equal (0.1 + 0.2 | into string | into float) 0.3 # 0.30000000000000004 == 0.3 assert error { assert equal 1 "foo" } assert error { assert equal (1 + 2) 4 } }