Add in support for import declarations and referencing external qux files.

This will require adding in a name resolution step (#15).

One of the steps should raise exceptions when an invalid function declaration is encountered.

This could be when it has the external attribute and a body, multiple external attributes or no attributes and no body.

Write tests for the NameResolver module.

The use of an extra CallExpr with an ApplicationExpr is quite confusing. I think I should remove CallExpr and change ApplicationExpr to allow qualified calls.

Compile the method contracts from #3 into the Quux intermediate language.

The TypeChecker fails if it comes across a call to a non-existent function. This should be reported with an actual exception (like how the Parser works).

See here.

Citing from http://hydra.cryp.to/build/1140271/log/raw:

src/Language/Qux/Annotated/Parser.hs:100:53:
    Ambiguous occurrence ‘<|>’
    It could refer to either ‘Control.Applicative.<|>’,
                             imported from ‘Control.Applicative’ at src/Language/Qux/Annotated/Parser.hs:25:1-26
                             (and originally defined in ‘GHC.Base’)
                          or ‘Text.Parsec.<|>’,
                             imported from ‘Text.Parsec’ at src/Language/Qux/Annotated/Parser.hs:32:1-40
                             (and originally defined in ‘Text.Parsec.Prim’)

src/Language/Qux/Annotated/Parser.hs:103:59:
    Ambiguous occurrence ‘many’
    It could refer to either ‘Control.Applicative.many’,
                             imported from ‘Control.Applicative’ at src/Language/Qux/Annotated/Parser.hs:25:1-26
                             (and originally defined in ‘GHC.Base’)
                          or ‘Text.Parsec.many’,
                             imported from ‘Text.Parsec’ at src/Language/Qux/Annotated/Parser.hs:32:1-40
                             (and originally defined in ‘Text.Parsec.Prim’)

Add in a test suite. It may be that I just have an integration test suite on the qux project rather than unit tests here.

Add in the full function type to a CallExpr so that it will be possible to remove the need to have a Context when type checking and compiling.

Write tests for the TypeResolver module.

hjwylde/qux#15

The TypeResolver fails if it comes across a call to a non-existent function. This should be reported with an actual exception (like how the Parser or TypeChecker work).

See here.

I think I prefer the Haskell syntax of () for a unit value and type, I'm considering converting nils to this.

We've updated llvm-general-pure in NixOS already, and now this package won't compile any more: http://packdeps.haskellers.com/feed?needle=language-qux. It would be great to get an update that remedies this.

Remove the external keyword and just determine whether a declaration is a prototype by whether it contains a body or not.

Add in the ability to declare external types.

This may be premature given that I don't even have user defined types, but it is needed for getting lists to work in #11.

Add in some documentation for the language features of Qux.

Add in a datatype for strings. Strings will be represented as a list of characters, i.e., [Char].

Add in a name resolution step between parsing and type resolution that fully qualifies all function references.

#5 added compilation to the LLVM IR but omitted nils - this needs to be added in.

Write an index doc that links to all the documentation available.

The NameResolver fails when either:

• an argument is passed to a local variable access or,
• there is more than 1 exporter of a function.

These errors should be reported with an actual exception (like how the Parser or TypeChecker work).

Write detailed documentation on the language features.

Implement a framework for the test suite.

Add in an external keyword that will allow for declaring external functions (functions without bodies).

This will make cross compiling with C possible.

Write tests for the Context module.

Implement a constant pool for when compiling to LLVM IR.

Write tests for the TypeChecker module.

#5 added compilation to the LLVM IR but omitted lists - this needs to be added in.

• Compile list type (qux_lang_list_List)
• Compile new list function (qux_lang_list_new)
• Compile list concat function (qux_lang_list_concat)
• Compile list length function (qux_lang_list_len)
• Compile list accessor functions (qux_lang_list_z_acc and qux_lang_list_l_acc for integer and list respectively)

The following are considered key language features that need implementing:

• Variable assignment (#9).
• String type (#10).
• Package declarations.
• Import declarations (#8).

Implement parametric polymorphism / generic types such that I can write useful library functions.

The NameResolver should raise an exception when it detects duplicate import statements.

Write a cheatsheet that summarises Qux's language features.

Add in assignment statement support.

Compile the method contracts from #3 into a language readable by a verification tool.

Add support for method contracts (requires and ensures keywords). Method contracts are mathematical statements that can be verified by a verification tool (think SMT solver or theorem prover).

The syntax of method contracts is still to be decided. I'll probably take some inspiration from Whiley and Dafny.

The extra package looks to have some useful functions that I've redefined. It might be possible to simplify a fair bit of the code by using it.

A top type will make it possible to type check empty lists. Currently an exception is thrown as it is not possible to infer what type the list should be.

Add in an HLint pre-hook and check for Travis.