A cross-platform functional programming language

Rationale and Philosophy


As a C++ developer, I have found that one of the most daunting and tiresome aspects of coding in C++ is the amount of boilerplate (but necessary) code that needs to be maintained.

I also observed that very often, the coder has to use various kinds of code generators.For example, lex/yacc, the moc of Qt, SWIG for integration layers to scripting languages, and so on.

Further, I realized that to achieve true parallelism in programming, one must appreciate, but go beyond the closures and continuations that most contemporary functional languages provide.

Finally, I firmly believe that C++ is here to stay. The past few months has seen a resurgence of interest in the C++ language, especially C++0x.

This is my humble effort at developing a language that integrates very tightly with C++ to give developers a "best of both worlds" solution - all the power of C++ combined with a simplicity of usage, and an easy transition between the two, where the developer sees this language more as a complement than a replacement to C++.


This application was written with the intent of providing advanced functional programming features for the C++ developer, while retaining the familiar C++ syntax as much as possible.

This language aims to reduce the amount of boilerplate code that the programmer has to maintain.

Further, it aims to simplify the work of a C++ developer by creating a clear and concise syntax over complex constructs such as lists, dictionaries, trees, iterators, etc.

The language provides easy two-way integration with C++, which will allow developers to reuse of existing libraries and code as much as possible.

In future, the language will make greater use of C++0x constructs as and when they become mainstream.

High Level Features

The language allows for the development of GUI applications using Qt's QML.

There are no pointers and NULLs. There are only value types and reference types, where every value must have a default initialization and every reference must have an associated value.

This language can be used in two ways:

The zen language is statically typed, with compile-time type interence. Using a dynamically typed language requires the programmer to remember a lot of context. For example, the coder will need to know the parameter types of various functions, and if there is a mistake, the error will manifest at run time. This increases errors when the team size changes. Unit testing does not help in such cases. It increases the amount of work to be done by a programmer to catch errors that could been caught by the compiler.


The Zen philosophy is to:

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines