What is a programmable programming language?
Take a "regular" programming language like Javascript. You define a function like so:
let add = (a, b) => a + b
You can then call the function with numbers as arguments:
You can also call the function with more complex arguments:
add(700 * 3 * 2, Math.pow(2, 16)) // Returns 69736
Importantly, the add function has no knowledge of the fact that you performed all those multiplications to compute the first argument, and it certainly doesn’t know that you called Math.pow to compute the second.
The Javascript runtime evaluates these two arguments before invoking add, so that by the time add is called, the call looks something like this:
In a language like Javascript, you can’t write this function in a way that allows add to inspect the operations that went into calculating its arguments.
In a Lisp dialect, though? It’s easy! You can write a special kind of function called a macro that receives all it’s arguments as-is. The macro can inspect the whole thing before deciding what to do, making some truly dynamic behavior possible.
Here’s the same add function in Clojure, a Lisp dialect:
(defn add [a b]
(+ a b))
(add (* 700 3 2) (Math/pow 2 16)) ; Returns 69736
So far this is the same as the Javascript version. The add function has no idea that you multiplied a bunch of numbers together to create its first argument, ditto for Math/pow.
Let’s create an add macro instead. To keep things simple, let’s have it print its arguments and return nothing:
(defmacro add [a b]
(println "arg a is" a "of type" (type a))
(println "arg b is" b "of type" (type b)))
And here’s what you’d see if you invoked it:
formulate=> (add (* 700 3 2) (Math/pow 2 16))
arg a is (* 700 3 2) of type clojure.lang.PersistentList
arg b is (Math/pow 2 16) of type clojure.lang.PersistentList
The add function is able to "see" its arguments in their entirety! Note that clojure.lang.PersistentList is simply the type Clojure uses for its linked list data structure, so these arguments can be manipulated just like regular lists.
Crucially, you can now have the add macro generate an implementation based on these arguments. You could run Math/abs on every single integer that was used to construct the arguments to add, or attempt to detect if one of the arguments has overflowed.
This was a very contrived example, but it goes to show how a programmable programming language can let you do things that are impossible in other languages.
