Deca: a functional, object-oriented, generic systems programming language
by Eli Gottlieb, copyright 2010-2011
November 1, 2011
-------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------

Deca is a language designed to provide the advanced features of sophisticated, high-level programming languages while still programming as close as possible to the bare metal.  It brings in the functional, object-oriented, and generic programming paradigms without requiring a garbage collector or a threading system, so programmers really only pay in performance for the features they use.

Deca provides first-class functions, lambdas, lexical closures to support functional programming.  It provides an object system in the style of CLOS, with generic functions and multimethods operating on hierarchical sum types (think of classes without inheritance), and structural typing makes tuples just another kind of record.  It provides type inference while still allowing and checking type annotations.  Region-based memory management is used in place of garbage collection to support data of dynamic lifetime, and option types replace null pointers.

-------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------

decac is Deca's compiler, written as a frontend compiler invoking LLVM (http:https://www.llvm.org).  It is written in Scala (http:https://www.scala-lang.org), with a parser in Java generated by SableCC (http:https://sablecc.org) from the grammar file deca.scc.  Its build system is based, currently, on Apache Ant (http:https://ant.apache.org), although the Java bindings I wrote for LLVM compile in their own fashion.

The entire thing is a work-in-progress right now, but I can safely say that (subject to a refutation of my proof that Deca's type inference always terminates) the type system and type inference are done.  I can also safely say that the syntactic grammar is likely to change for the better and clearer as I find ways of eliminating the ambiguities that arise from attempting to simplify it.

To compile decac, run:
$ ant build_parser
$ ant build_llvm_bindings
$ and build

The parser need only be rebuilt when deca.scc has been altered, and building the LLVM Java bindings once for every revision of LLVM should be enough.

Happy hacking!
--Eli Gottlieb