Linux Fu: The Shell Forth Programmers Will Love

One of the most highly effective options of Unix and Linux is that making use of conventional command line applications, everything is a stream of bytes. Granted, modern-day computer software has blurred this a little bit, but at the command line, anything is text with specific free conventions about what separates fields and data. This lets you do points like consider a directory listing, kind it, take away the duplicates, and evaluate it to a different directory listing. But what if the shell understood a lot more knowledge kinds other than streams? You could possibly argue it would make some matters improved and some factors even worse, but you really do not have to guess, you can put in cosh, a shell that delivers equipment to deliver and function with structured information sorts.

The process is composed with Rust, so you will have to have Rust set up to compile it. For most distributions, which is just a bundle install (rust-all in Ubuntu-like distros, for instance). After you have it managing, you’ll have a several new items to discover as opposed to other shells you’ve utilized.

Illustrations

A very good way to get a fast taste of the shell’s idiosyncracies is to contrast it with the common shell syntax. The Github webpage has numerous superior illustrations:

• Discover files matching a route, and research them for data:

sh: find . -iname ‘*test*’ -print0 | xargs – grep knowledge
cosh: lsr [test m] grep [f<; [data m] grep] map

• Discover the whole sizing of all data files in the present directory:

sh: ls | xargs stat -c %s | awk ‘s+=$1 End print s’ –
cosh: ls [is-dir; not] grep [stat; size get] map sum

• Get the next and third columns from every row of a CSV file:

sh: lower -d, -f2,3 exam-data/csv
cosh: take a look at-knowledge/csv f< [chomp; , split; (1 2) get] map

• Sort files by modification time:

sh: ls -tr
cosh: ls [[stat; mtime get] 2 apply <=>] sortp

As you can see, occasionally instructions are a minimal for a longer period, but presumably, there is considerably less to recall, and it is a bit far more self-documenting.

But Why?

The vital idea is that this shell understands a number of information forms. In distinct, it can deal with hash maps, sets, and lists. Essential items consist of booleans, integers (32-bit or of arbitrary measurement), floats, and strings.

The enter prompt is extra like a command prompt for a programming language. In actuality, Forth programmers will appreciate the RPN abilities:

/tmp/cosh$ 5 3 /
1
/tmp/cosh$ 5. 3 /
1.6666666666666667
/tmp/cosh$

Storing into variables is similar to Forth, as well, working with ! and @ with the RPN-design and style notation. In actuality, it all appears to be like like Forth from swap and drop to the way if controls conditionals. Nevertheless, the stack does not exist amongst strains. So the over illustrations do not depart the final result on the stack.

The documentation on Github is excellent, but there are a couple factors you are going to have to do the job out. For instance, the string perform ++ is documented, but the instance employs the term append, which does not feel to do the job.

/tmp/cosh$ hacka day ++
hackaday
/tmp/cosh$ hacka working day append
hacka
day
append

Commands and Standard Expressions

Most shell commands exist in cosh, much too, but not essentially as external resources. Some have aliases, much too. For case in point, you can use mv, but you can also use rename. All the things is, of training course, utilizing the RPN format for arguments.

If you want an external command, you will need to prefix it with a greenback indicator or, in an interactive shell, you can use a space if you like. For illustration, if you run ls, you will get the cosh variation of ls. If you run $ls, that’s the true ls command you count on.  If you place the external name in braces, what is returned is a generator that will allow you to stroll via the output.

What’s a shell without frequent expressions? With cosh, you have an “m” expression that tells you if you have a match or a “c” situation that returns captures from the expression. There are also “s” expressions for search and change. You can also incorporate flags to let diverse solutions like scenario insensitivity.

I located the capture element baffling. You’d believe it would supply a record of items matched in parenthesis, but either it does not or I couldn’t come across the appropriate syntax to make it do so. For example:

/tmp/cosh$ identify=al "name=(.*)$" c
(
   : name=al
)
/tmp/cosh$ identify=al,identify=jim "identify=([a-zA-z]+)/g" c
(
   : title=al
   1: name=jim
)

The documentation demonstrates some examples of this that don’t do the job just proper, also. For illustration, attempt this from the documentation:

/tmp/cosh$ asdf "(..)" c

To get the result the doc shows, you need to have the /g flag on the common expression. In any other case, only the initial match seems.

Parsing

A person major aspect of cosh is that it can parse json and XML. It can also create out files in that structure. We’d adore to see a proper CSV parser, despite the fact that that is a minimal less complicated to handle directly with cosh primitives than an XML file.

For example, if you want the 3rd and 4th fields from a CSV file, you can go through it and use the split and get functions in a map:

/tmp/cosh$ test.csv f< [chomp; , split; (3 4) get] map

Of course, that’s not going to handle things like quoted values, but that’s typically a problem in other simple shell scripts, too.

Working with json is easy. For example, if you want to find the fields that match a regular expression, you can do that:

file.json f< from-json keys [.4 m] grep&#13
v[gen (
0: asdf
1: qwer
2: tyui
3: zxcv
)]  # from the official examples

Winner?

Will we start using cosh every day? Honestly, probably not. But it is interesting. We might keep it in our back pocket for writing scripts that need to process json or XML.

We like the Forth syntax, but not everyone will. We also like the data typing. But as a general-purpose shell, it seems to leave something to be desired.

Of course, what we really like is Linux gives you choices. If you like cosh, knock yourself out. Don’t like it? Pick another shell or — if you are feeling brave — write you own. The world is your oyster.

We couldn’t help but think of the database-like Crush shell while playing with cosh. Then here’s cat9, which is a strange shell, indeed. There are, too, some more mainstream alternative shells like zsh and fish.