forked from extern/nushell
7a77910720
There are many use cases. Here we introduce the following:
- The rows can be rolled `... | roll` (up) or `... | roll down`
- Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction)
- You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`)
- Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll.
Basic working example with rolling columns:
```
> echo '00000100'
| split chars
| each { str to-int }
| rotate counter-clockwise _
| reject _
| rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8
───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────
# │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8
───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────
0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0
───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────
```
We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it:
```
> echo '00000100'
| split chars
| each { str to-int }
| rotate counter-clockwise _
| reject _
| rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8
| roll column 3
───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────
# │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3
───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────
0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0
───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────
```
The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing.
We can roll the cell contents only to fix it.
```
> echo '00000100'
| split chars
| each { str to-int }
| rotate counter-clockwise _
| reject _
| rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8
| roll column 3 --cells-only
───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────
# │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8
───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────
0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0
───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────
```
There we go. Let's compute it's decimal value now (should be 32)
```
> echo '00000100'
| split chars
| each { str to-int }
| rotate counter-clockwise _
| reject _
| roll column 3 --cells-only
| pivot bit --ignore-titles
| get bit
| reverse
| each --numbered { = $it.item * (2 ** $it.index) }
| math sum
32
```
64 lines
736 B
Rust
64 lines
736 B
Rust
mod append;
|
|
mod autoenv;
|
|
mod autoenv_trust;
|
|
mod autoenv_untrust;
|
|
mod cal;
|
|
mod cd;
|
|
mod compact;
|
|
mod count;
|
|
mod cp;
|
|
mod def;
|
|
mod default;
|
|
mod drop;
|
|
mod each;
|
|
mod echo;
|
|
mod empty;
|
|
mod enter;
|
|
mod every;
|
|
mod first;
|
|
mod flatten;
|
|
mod format;
|
|
mod get;
|
|
mod group_by;
|
|
mod hash_;
|
|
mod headers;
|
|
mod histogram;
|
|
mod insert;
|
|
mod into_int;
|
|
mod keep;
|
|
mod last;
|
|
mod lines;
|
|
mod ls;
|
|
mod math;
|
|
mod merge;
|
|
mod mkdir;
|
|
mod move_;
|
|
mod open;
|
|
mod parse;
|
|
mod path;
|
|
mod prepend;
|
|
mod random;
|
|
mod range;
|
|
mod reduce;
|
|
mod rename;
|
|
mod reverse;
|
|
mod rm;
|
|
mod roll;
|
|
mod rotate;
|
|
mod save;
|
|
mod select;
|
|
mod semicolon;
|
|
mod skip;
|
|
mod sort_by;
|
|
mod split_by;
|
|
mod split_column;
|
|
mod split_row;
|
|
mod str_;
|
|
mod touch;
|
|
mod uniq;
|
|
mod update;
|
|
mod where_;
|
|
mod which;
|
|
mod with_env;
|
|
mod wrap;
|