Ix is a multi-paradigm programming language directly supporting OOP, functional, procedural, and production-based programming methodologies.  Notes about its development can be found on [my blog](http://blog.fogus.me/tag/ix).

Functions
==========
Functions are defined via the `fn` special form:

    fn( foo [X] out("Got " X crlf))

Functions can take a variable number of arguments with the use of the sequence implosion declaration (must always be in the last argument position):

    fn( foo [X Y:*_] out("Got " X " with additional " Y crlf))

Function calls are done by following any symbol with a parenthesized set of atoms, variables, or numbers:

    foo(1 2 3 "foo" a b c [x y z])

Function names are simply symbols and can be called indirectly via `call`:

    call(foo 1 2 3))

Since function names are symbols, they can be stored in variables and also called indirectly:

    let X <- foo
    call(X 1 2 3)

If you prefer, the variable holding the function name can be used in the function call form directly:

    let X <- foo
    X(1 2 3)

Directives
==========

Directives are used to change the normal behavior of Ix.  They are indicated using the colon operator and often appended to the end of function name or variables or stand on their own in certain positions.

`*_` Sequence expansion/implosion
----------------------------------
Used to expand a list into function arguments.  This can only be used within a function call:

    let X <- _(1 2 3)
    out(X)                    ;; prints (1 2 3)
    out(X:*_)                 ;; prints 1 2 3

`ever` Infinite looping
------------------------
Used to make the `for` function operate as an infinite loop.  Typically, the `for` function operates on a list, iterating through each of the elements one at a time.  However, with the `ever` directive, it can be made to operate like a `while(true)` loop.

    ;; Normal for loop
    let X <- _(1 2 3)
    for(E <- X
      out(E))                      ;; prints 1 2 3 

    for(:ever
      out("Hello Cleveland ")) ;; prints Hello Cleveland forever 

`index` Gets the current loop index
------------------------------------
Used the grab the current index of a loop.  It is appended to the end of the loop variable to access.

    let X <- _(a b c)
    for(E <- X
      out(E @ E:index " "))    ;; prints a@0 b@1 c@2

TODO
----
1. Serialize to source
2. Any function can (potentially) be infix
3. Knowledge as data type
4. Anonymous functions
5. Extension API
6. Loadable modules