> Genera knows the actual type of everything
I have this side-project fantasy of a very simple terminal pipe-types project. The basic idea is a set of very basic standardized types, demarcated using escape sequences. Dates, filenames, URLs, numbers, possibly one or two number units as well (time periods, file sizes only).
Tools that already produce columnar data (ls) get a flag that lets them output this format, and tools that work with piped data (cut, sort, uniq) get equivalents or modes that let them easily work with this.
Essentially, simple typed tables held in text, with enhancements for existing tooling to know how to deal with it. Would make my day-to-day on the command line much easier.
I think PowerShell works this way essentially. As I understand, all data is structured which makes formatting and piping to other programs much simpler.
Could be fun :)
But note that on the Lisp Machine/Genera, every type has a presentation and can be “printed” to the REPL. This includes any new classes that you create as part of your own programs. It’s not just a small list of standard types, but every type.
The standard tutorial for the system is to implement Conway’s Game of Life. It has you create a class to hold the game board and then guides you through the process of defining a presentation for it so that the it can be displayed easily.
Arcan is experimenting with something like this (among others): https://arcan-fe.com/2024/09/16/a-spreadsheet-and-a-debugger...
See also:
* NuShell (https://www.nushell.sh/)
nushell goes in that direction. Programs can output tables, and the shell (or other tools) know how to work with this structured data.
I always thought to do that by having a virtual file system that tags my files and so they are available at specific location if they fit the bill.
https://kellyjonbrazil.github.io/jc/docs/parsers/ls.html
...glom on to this: "+JSONSchema" with some sort of UNIX-ish taxonomy. Everything from `man test`, add in `man du`, `date`, `... ago` (relative time) as you'd mentioned.
`jc ls | add_schema...` => `jq ...`
...or `jc ls --with-schema | jq ...`
(it appears as though `jc` already supports schema's, so perhaps it'd be `jc ls --with-types` or something, but there's your starting point!)
That's neat and a similar idea. I think JSON probably ends up being too expressive (not just an array of identically-shaped shallow objects), too restrictive (too few useful primitives), and also too verbose of a format, but the idea of a wrapping command like that as a starting point is neat
I'll share this comment from 7 months ago with you:
https://news.ycombinator.com/item?id=40100069
"prefer shallow arrays of 'records', possibly with a deeply nested 'uri'-style identifier"
...the clutch result is: "it can be loaded into a database and treated as a table".
The origin of this technique for me was someone saying back in 2000'ish timeframe (and effectively modernized here):
sqlite-utils insert example.db ls_part <( jc ls -lart )
sqlite3 example.db --json \
"SELECT COUNT(*) AS c, flags FROM ls_lart GROUP BY flags"
[
{
"c": 9,
"flags": "-rw-r--r--"
},
{
"c": 2,
"flags": "drwxr-xr-x"
}
]
This particular example is "dumb" (but ayyyy, I didn't get a UUOC cat award!) in that you can easily muddle through it in different (existing pipeline) ways, but SQL crushes the primitive POSIX relationship tooling (so old, ugly, and unused they're tough to find!), eg: `comm`, `paste`, `uniq`, `awk`