EC

A stack-based calculator with vectors and quotations

EC is a useful command-line RPN calculator. It’s designed to be powerful and efficient from the command line.

EC’s design has several inspirations:

• dc, the reverse-polish desk calculator which comes standard on many UNIX systems;
• J, an language in the APL family which has operators that can work on arbitrary-dimensional arrays;
• Manfred von Thun’s Joy, a concatenative functional language which uses quotations to do functional programming.

Taken together, EC tries to harmonize three powerful concepts:

• reverse-polish notation,
• array operations,
• and quotations.

Reverse-Polish notation

⊕ ec 10 5 +
15

In Reverse-Polish Notation (or RPN), mathematical operations are expressed with the operator in the final place.

While this appears a little unfamiliar, it has some real benefits. Chief among them: there is no concept of operator precedence and no need for parentheses to indicate order of operations. There is no ambiguity between 4 + 2 * 4 and (4 + 2) * 4; those would be 2 4 * 4 + and 2 4 + 4 * (or 4 2 4 + *) respectively. When writing quick sums on the command line, it helps to not have to futz with parenthesis and infix notation.

Array Operations

In addition to ordinary integer and floating point numbers, EC introduces Vectors, which are multi-dimensional lists of numbers. EC operators can work on vectors of different shape without any special notation. For example, here we see operations between two numbers, a number and a vector, two vectors, and vectors of differing shape:

ec 100 0.65 x
65

⊕ ec [3.15 3.20 3.50 3.65 3.85] 0.65 x
[2.0475 2.08 2.275 2.3725 2.5025]

⊕ ec [3.15 3.20 0.350] [0.65 0.80 0.75] x
[2.0475 2.56 0.2625]

⊕ ec [[3.15 3.20 0.350] [100 200 300]] [0.65 0.80 0.75] x
[[2.0475 2.56 0.2625] [65 160 225]]

Quotations

Finally, a sequence of symbols can be wrapped in parentheses or curly braces to form Quotations, which is unevaluated code. These unevaluated programs can be manipulated by Combinators like dist, below, to perform powerful higher-level functional operations.

In this example, dist inserts the quoted operation in between each element of the vector. It’s trivial to construct a program to find the sum of a list of numbers out of these primitives.

⊕ ec [2.5 100 2 14] 0 {+} dist
118.5

Operators that are manipulated by combinators are designed to remain fully compatible with array math, as in the following example:

⊕ ec [[2.5 100 2 14] [45 55 65 75] [100 99 98 97]] 0 {+} dist                                      
[147.5 254 165 186]

Combinators

EC inherits (lifts wholesale) from Joy many useful Combinators: programs which manipulate one or more quotation to accomplish powerful, complex operations. Here are som examples, along with descriptions from EC’s help system.

dist

⊕ ec {/} ?
--

dist: dist

S v a q -- S
Insert `a`, then apply quotation `q` after every element of `v`.

---

⊕ ec [2.5 100 2 14] 0 {+} dist
118.5

fork

⊕ ec {fork} ?
--

fork: fork

S a q p -- S a' a''
Apply q to a, and p to a, and push the results on the stack.

---

⊕ ec [34 20 12] {0 {+} /} {length} fork %
22

primrec

⊕ ec {primrec} ?                                        
--

primrec: primrec

S d zq oq -- S

Primitive recursion.

> If the data parameter is [zero or empty], then the first quotation has to
> produce the value to be returned. If the data parameter is
> positive then the second has to combine the data parameter with
> the result of applying the function to its predecessor.
Manfred von Thun, _Tutorial on Joy_

---

⊕ ec 5 {1} {*} primrec
120