Dreams about metaprogramming in Kalimat

(Note: These are only design thoughts - I do not promise that all or any of those features will actually be in Kalimat).

I'm a big Lisp fan. It seems I can't create a language without trying to turn it into a Lisp. One of the reasons Kalimat got finished in the first place was that I decided to forget all the macros and metaprogramming and try my best to do a good "normal" language.

But now macros call me again...

The first thing I want to add is reified parse trees. I'll make the examples in Kick - the English version of Kalimat - because the Blogger editor has problems with mixing Arabic and English text. But if I implement this it will probably be implemented in Kalimat first.

Now consider this code:

m = myParseTree( )
print m: toString( )

What should be its expected output? Probably something like this:

Program(
    statements = [
        assignmentStmt(m, functionCall(myParseTree, [])),
        printStmt(methodCall(m, toString, [])) ])

Looks like Lisp already :). The program here can see the objects that represent its own parse trees. This has many benefits. For example I can create automatic documentation tools, write code to convert a program into another language, create programs that do code generation or code verification, all without needing to write a Kalimat parser!

Modifying the trees

In a possible next step, I can make the program modify it own parse trees, and enable something like Lisp macros, C++ template metaprogramming, or MetaLua.

What do I mean? Suppose I could mark some functions as special "compile time code". Then I can write a function like this:

compiletime function const(code ~ expression):
code: replace(evaluationOf(code))
end

...and use this function like so:

x = const(sin(0.5) * cos(3) / factorial(3))                      

This will result in the code becoming like this; before the program is compiled:

x = -0.0791046143

Notice what happened: The program's parse tree was modified to replace an expression without variables with its own result (an optimization called constant-folding). This means that during the program's run the expression won't need to be evaluated.

What other tricks can we do? Imagine:

classFromDbTable("person")
classFromDbTable("department")

...and before compilation this code becomes:

class person:
 has name, id, department, salary
 responds to save(db), load(db)
end

class department:
 has name, location
 responds to save(db), load(db)
 replies to getEmployees()
end

Here the compiler ran the "classFromDbTable" macro, which made a connection to the database, retrieved the needed information about tables and relations, and generated a class for each of the given table with methods to save a record, load a record, or retrieve related records.

Even more dreams

What can we do next? This is an active research area and I don't know if I can/want to implement this; but we could allow certain Kalimat modules to modify the parser before compilation. It means a Kalimat program can define a special version of Kalimat syntax and then we write the rest of that program in the new syntax! For example, if we are developing a game, we can make special syntax for declaring a game character:

syntax character:
  codeForm: ...how it should look...
  translation: ...actual kalimat code it should become...
end

...and then use the new syntax as if it were part of the existing Kalimat syntax:

character Ship:
  image "ship.png"
  control = keyboard
  ai attack(enemy), maneuver(map)
end

ai attack for ship(enemy):
 ...implement attack...
end

ai maneuver for ship(map):
 ...implement maneuver...
end

So, what's the purpose of this article? First: to show you that compile-time meta-programming is cool. Right? :)

Second, to share with you some features I'm considering for Kalimat and hear any comments or suggestions.

Third, this article also answers a question I sometimes get: Why reinvent the wheel implementing a new language with its own parser, compiler, VM...etc. The answer is because Kalimat is not a translation of an existing language: it is a brand new language with its own features, design, and ideas.