mirror of
https://github.com/nushell/nushell
synced 2024-12-26 04:53:09 +00:00
9f09930834
# Description Dividing two ints can currently return either an int or a float. Not having a single return type for an operation between two types seems problematic. Additionally, the type signature for division says that dividing two ints returns only an int which does not match the current implementation (it can also return a float). This PR changes division between almost all types to return a float (except for `filesize / number` or `duration / number`, since there are no float representations for these types). Currently, floor division between certain types is not implemented even though the type signature allows it. Also, the current implementation of floor division uses a combination of clamping and flooring rather than simply performing floor division which this PR fixes. Additionally, the signature was changed so that `int // float`, `float // int`, and `float // float` now return float instead of int. This matches the automatic float promotion in the rest of the operators (as well as how Python does floor division which I think is the original inspiration). Since regular division has always returned fractional values (and now returns a float to reflect that), `mod` is now defined in terms of floor division. That is, `D // d = q`, `D mod d = r`, and `D = d * q + r `. This is just like the `%` operator in Python, which is also based off floor division (at least for ints and floats). Additionally, implementations missing from `mod`'s current type signature have been added (`duration mod int` and `duration mod float`). This PR also overhauls the overflow checking and errors for div, mod, and floor div. If an operation overflows, it will now cause an error. # User-Facing Changes - Div now returns a float in most cases. - Floor division now actually does floor division. - Floor division now does automatic float promotion, returning a float in more instances. - Floor division now actually allows division with filesize and durations as its type signature claimed. - Mod is now defined and implemented in terms of floor division rather than truncating division. - Mod now actually allows filesize and durations as its type signature claimed. - Div, mod, and floor div now all have proper overflow checks. ## Examples When the divisor and the dividend have the same sign, the quotient and remainder will be the same as before. (Except that this PR will give more accurate results, since it does not do an intermediate float conversion). If the signs of the divisor and dividend are different, then the results will be different, or rather actually correct. Before: ```nu let q = 8 // -3 # -3 let r = 8 mod -3 # 2 8 == $q * -3 + $r # false ``` After: ```nu let q = 8 // -3 # -3 let r = 8 mod -3 # -1 8 == $q * -3 + $r # true ``` Before: ```nu let q = -8 // 3 # -3 let r = -8 mod 3 # -2 -8 == $q * 3 + $r # false ``` After: ```nu let q = -8 // 3 # -3 let r = -8 mod 3 # 1 -8 == $q * 3 + $r # true ``` # Tests + Formatting Added a few tests. # After Submitting Probably update the docs. |
||
|---|---|---|
| .. | ||
| nu-cli | ||
| nu-cmd-base | ||
| nu-cmd-extra | ||
| nu-cmd-lang | ||
| nu-cmd-plugin | ||
| nu-color-config | ||
| nu-command | ||
| nu-derive-value | ||
| nu-engine | ||
| nu-explore | ||
| nu-glob | ||
| nu-json | ||
| nu-lsp | ||
| nu-parser | ||
| nu-path | ||
| nu-plugin | ||
| nu-plugin-core | ||
| nu-plugin-engine | ||
| nu-plugin-protocol | ||
| nu-plugin-test-support | ||
| nu-pretty-hex | ||
| nu-protocol | ||
| nu-std | ||
| nu-system | ||
| nu-table | ||
| nu-term-grid | ||
| nu-test-support | ||
| nu-utils | ||
| nu_plugin_custom_values | ||
| nu_plugin_example | ||
| nu_plugin_formats | ||
| nu_plugin_gstat | ||
| nu_plugin_inc | ||
| nu_plugin_nu_example | ||
| nu_plugin_polars | ||
| nu_plugin_python | ||
| nu_plugin_query | ||
| nu_plugin_stress_internals | ||
| nuon | ||
| README.md | ||
Nushell core libraries and plugins
These sub-crates form both the foundation for Nu and a set of plugins which extend Nu with additional functionality.
Foundational libraries are split into two kinds of crates:
- Core crates - those crates that work together to build the Nushell language engine
- Support crates - a set of crates that support the engine with additional features like JSON support, ANSI support, and more.
Plugins are likewise also split into two types:
- Core plugins - plugins that provide part of the default experience of Nu, including access to the system properties, processes, and web-connectivity features.
- Extra plugins - these plugins run a wide range of different capabilities like working with different file types, charting, viewing binary data, and more.