tot — command-line postfix calculator

I want tot expressions to require minimal shell quoting. So, most words are spelled without any shell metacharacters. When a metacharacter makes an obviously good word-name, I usually define an "uglier" synonym so that quoting can be avoided. Examples:

	Obviously Good	Ugly Synonym
	**	pow
	^	pow
	'	quote
	"	string
	*	x
	<	lt
	<=	lte
	>	gt
	>=	gte
	<>	not
	[	vec

I believe that, for a calculator, postfix is inherently superior to infix, but additionally, parentheses are shell metacharacters, so with infix notation most expressions require shell quoting; see above.

Many calculators print results in a way that sometimes requires neatening-up. dc prints big numbers with backslashes, some calculators print prompts, insert leading whitespace, etc.

tot just prints the stack, one element per line (the -1 option only prints the top element). tot has multiple data types, and my approach is to print them cleanly i.e. ambiguously, with no syntax or delimiters to disambiguate them.

tot now has simple Posix regular expression matching via four new words:

imatch	( s r – b )	does regex r match string s (case-insensitively)?	PRIMITIVE
imatches	( s r – v )	extract substrings for regex r from string s (case-insensitively)	PRIMITIVE
match	( s r – b )	does regex r match string s?	PRIMITIVE
matches	( s r – v )	extract substrings for regex r from string s	PRIMITIVE

Matching example:

$ (seq 4; echo foo; echo bar)
1
2
3
4
foo
bar
$ (seq 4; echo foo; echo bar) | tot in :: string '^[0-9]+$' match end filter
1       2       3       4
$ (seq 4; echo foo; echo bar) | tot in :: string '^[0-9]+$' match not end filter
foo     bar
: jfcl;

Parenthesized substrings are extracted by matches (and imatches) and result in a vector of strings. If the match succeeds, the vector is of length m+1 where m is the number of parenthesized substrings; the first element of the vector is the entire matching text. If the match fails, the vector is empty (which can be matched with the new word null:

null

( v – b )

is vector v empty?

PRIMITIVE

Example:

$ echo foo: 56 bar: 72 | tot in hd string 'foo: ([0-9]+) bar: ([0-9]+)' matches unpack
foo: 56 bar: 72
56
72
$

The new word field provides simple subfield extraction from lines:

field

( x i s – n )

extract field i from s-separated string x

rot swap split swap nth

$ tot @ /etc/passwd lines :: 0 string : field end map :: len 4 lte end filter unpack
root
bin
mail
ftp
http
dbus
ntp
exim
ldap
mpd
git
rpc
: jfcl;

The relational operators lt, lte, gt, gte, ne (and their synonyms) now work on strings as well as numbers.

In debug mode (-d), stack values are now displayed unambiguously.

$ tot 12345 string 12345 @ 12345 vec 12345 end
12345
12345
12345
12345
$ tot -v 12345 string 12345 @ 12345 vec 12345 end
VEC     12345
FILE    12345
STRING  12345
NUM     12345
$ tot -d 12345 string 12345 @ 12345 vec 12345 end
12345
12345
12345
12345
[0 EMPTY]  | 12345 string 12345 @ 12345 vec 12345 end
[1 NUM] 12345 | string 12345 @ 12345 vec 12345 end
[2 STRING] 12345 "12345" | @ 12345 vec 12345 end
[3 FILE] 12345 "12345" <12345> | vec 12345 end
[4 VEC] 12345 "12345" <12345> [12345] |
: jfcl;

Strings are displayed within double quotes, with "non-printable" values escaped (as for OCaml):

$ tot -d string "1 2\"3

4 ^E" > /dev/null
[0 EMPTY]  | string 1 2"3

4
[1 STRING] "1 2\"3\n\n4 \005" |
: jfcl;

Filenames are displayed within angle brackets and vectors within square brackets.

In addition, the debugger now displays the type of the top item on the stack after the stack depth.

Prints a stepwise stack trace during evaluation.

tot now has lambda expressions for use with the functionals. The immediate word lambda (synonym: ::) is just like : except it doesn't take a name.

$ tot file /etc/passwd lines :: string : split hd end map unpack
root
bin
daemon
mail
ftp
http
uuidd
dbus
nobody
keith
ntp
avahi
exim
ldap
mpd
git
polkitd
$