Expression evaluation built with explorable graphs
npm install @explorablegraph/exlangExplorable functions could form the organizing information model of a programming language.
Consider a language with Lisp syntax based on explorable functions (exfns).
``lisp`
(exfn a b c)
A C-style language (including an evolved JavaScript) would write this as
`c`
exfn(a, b, c);
These both mean to ask explorable function exfn for the object with key (a b c). In current JavaScript, this project expresses the C-style call as:
`js`
exfnapply;
The rest of this page considers a hypothetical programming language based on exfns.
_Note: The syntax here is just noodling, and something of a mess. The underlying concept feels extremely sound, however._
The language needs a syntax for defining the following elements for an explorable function:
- Name (exfn, above): the key that will be used to register the exfn in an explorable namespace (graph) of defined functions. This makes the defined exfn available to other functions.
- A graph that declares the exfn's keys/members:
- Public keys, if any, and their implementation.
- A public key which returns the exfn's public keys.
- Hidden keys, if any, and their implementation.
Defining an exfn to map lowercase letters to uppercase letters might look like:
`js`
lowerToUpper = {
a: "A",
b: "B",
c: "C",
};
This defines an exfn with the name lowerToUpper with the public keys ['a', 'b', 'c'].
The language needs some syntax for unique symbols as a key. Perhaps we introduce #keys to mean such a unique symbol. In this language, we can get the public keys for an object:
`js`
lowerToUpper.#keys; // Returns ['a', 'b', 'c']
Who defines #keys? The exfn definition above is implicitly composed with a definition for the base explorable function object/class/definition.
Defining an exfn to add numbers in a C-style language might look like:
`js`
add = {
(a, b) => a + b,
};
This defines a graph with no public keys. The #keys key returns an exfn [] (always returns undefined, no public keys itself).
An exfn can explicitly define keys using the #keys symbol.
The following function converts letters to uppercase:
`js`
lowerToUpper = (lower) => lower.toUpperCase();
This implicitly has an empty #keys exfn. The function can also provide examples of the values it will accept:
`js`
lowerToUpper = {
a: "A",
b: "B",
c: "C"
} + (lower) => lower.toUpperCase()
This can be useful for math functions too:
`js`
fibo = {
#keys: { { 0, 1 }, { 1, 1 } }
} + (a, b) => // Do the math
This fibonacci function can do the math, as well as provide examples of the tuples it accepts.
An exfn can define a hidden key X with [X]. These will not be included in the exfn's publicly-inspectable #keys.
`js
lowerToUpper = {
a: "A",
b: "B",
c: "C",
[secret]: "You have found the secret value!",
};
lowerToUpper.a; // "A"
lowerToUpper.#keys; // { a, b, c}
lowerToUpper.secret; // You have found the secret value
`
Invoking a method on an exfn — or, alternatively, traversing the graph it defines — is a matter of traversing the graph expressed by the exfn.
Using the example add definitions above, the invocation add(1, 2) or (add 1 2) means: traverse theadd graph with a tuple(1, 2). The add definition responds with the sum of the numbers.
Many common data structures can be represented as explorable functions: arrays, lists, trees, strings.
The language must provide an intrinsic exfn definition that provides a way to modify a graph at runtime.
Object-oriented concepts can be expressed by composition of declaration graphs: nodes in the declaration graph for exfn A can point to other declaration graphs. If A incorporate's exfn B's graph, A can be said to inherit from B.
A common pattern is to have a key represent a tuple (method ...args).
A String class as an explorable function:
``js`
String = {
append: (s) => { / Calculate value + s, set that as new value. / },
length: () => { / get length / },
value: null,
})
Given this representation, a variable of type string is an exfn that composes the definitions of String.
`js`
message =
{
value: "Hello",
} + String;
Here, the + operator returns a new graph that composes subgraphs a and b. The resulting exfn will search in graph a for key first, and if not found will look in graph b. The compose operation also composes the #keys of the subgraphs.
One can then make invocations such as:
`js`
message.value; // "Hello"
message.length; // 5
message.definition; // Returns message's definitions, including those of String
The package of Explorable intrinsics in this project are written in JavaScript, but the algorithms behind them are universal and inherently portable to explorable functions implemented in any language. That is, any language built around explorable functions would also pick up a well-defined set of useful operations.
The concept could also be easily represented with a Lisp-like syntax. The add example earlier:
`lisp``
(define add
(lambda
(a b) (+ a b)
)
)