# xasm
A cross platform, compiled and dynamically typed programming / intermediate language

Xasm is meant to be an intermediate representation for compiled and dynamically typed programming languages. However, xasm is still itself suitable for scripting.

## Features
- Dynamic typing
- Lua-like speeds
- An easy to use Rust foreign function interface
- First class support for Functional and Object Oriented programming
- Simple syntax

## Documentation
You can find the virtual machine's documentation [here](https://docs.rs/xmachine), and the compiler backend documentation [here](https://docs.rs/xassembler). Both of these components are called `xmachine` and `xassembler` respectively, and you can find them on my GitHub account.

```bash
$ xasm

xasm x.x.x
Adam McDaniel <adam.mcdaniel17@gmail.com>
Compiler for the xasm programming language

USAGE:
    xasm [SUBCOMMAND]

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

SUBCOMMANDS:
    compile    Compile a xasm file
    help       Prints this message or the help of the given subcommand(s)
    run        Run a xasm file
```

## Examples

Here's how you implement basic control flow structures in xasm.

```rust
value = 1

if value {
    println("`value` is not 0")
} else {
    println("`value` is 0")
}


while 1 {
    println("Still looping!")
}
```

Keep in mind that xasm is intended to be an intermediate representation!

#### Object Oriented Programming
To write object oriented code in xasm, first you write a class.
```rust
class Point {
    fn new(self, x, y) {
        self.goto(x, y)
        self
    }

    self.goto(self, x, y) {
        self.x = x
        self.y = y
    }
}
```

The `new` method is typically used to instantiate an object, but you can write other constructors if you'd like. The reason we use the `new` method is because the `new` function will call our class's `new` function to construct our object.

Here's how we would construct our `Point`.

```rust
p = new(Point, 2, 3)
```

#### Functional Programming
Because xasm supports closures, you can easily implement church encodings.

```rust
fn True(a) {
    fn(b) { a }
}

fn False(a) {
    fn(b) { b }
}

fn If(c) {
    fn(a) {
        fn(b) {
            (c(a))(b)
        }
    }
}
```

In addition, you can use more practical functional programming techniques.

```rust
multiply = fn(n) {
    fn(m) {
        mul(n, m)
    }
}

double = multiply(2)
triple = multiply(3)

println(double(3))
println(triple(3))
```

## Installation

Install Rust

```bash
# For *nix users
# If you're a windows user, go to https://rust-lang.org
curl https://sh.rustup.rs -sSf | sh
```

Install / update xasm

```bash
cargo install -f xasm
```

## Issues

If you run into a problem, [post an issue](https://github.com/adam-mcdaniel/xasm/issues/new)!

## License

xasm is distributed under the terms of the Apache License (Version 2.0).

See LICENSE for details.