# 🌸 hana
[![travis](https://travis-ci.org/ffwff/hana.svg?branch=haru)](https://travis-ci.org/ffwff/hana)
[![codecov](https://codecov.io/gh/ffwff/hana/branch/haru/graph/badge.svg)](https://codecov.io/gh/ffwff/hana)
[![Gitter](https://badges.gitter.im/flowers-of-spring/community.svg)](https://gitter.im/flowers-of-spring/community)
**hana** is a small dynamically-typed scripting language written in Rust/C
and is inspired by Pascal, Ruby and Javascript. It primarily supports prototype-based
object orientation, dynamic arrays, first-class functions (with closure support). The interpreter
comes useful features such as a simple mark-and-sweep garbage collector, exception handling
and an import system.
**haru**, the Rust parser/runtime generates bytecode that runs on an optimised
virtual machine written in C (about as fast as Python and Ruby!)
## Installation
You'll need to have the cargo package manager and rust installed. You can then do:
```
cargo install haru
```
The interpreter called `haru` will be installed into your PATH.
### Additional features
Additional features can be enabled by passing their names into
cargo's `--features` flag:
* `jemalloc`: use the jemalloc memory allocator
* `cffi`: enables the stdlib's C foreign interface *(wip)*
## Running
Once built or installed, you can write hana code into a source file, then invoke the interpreter like this:
```
haru program.hana
```
Alternatively you could invoke a REPL for easier prototyping:
```
haru
```
For usage, pass the `-h` command:
```
usage: haru [options] [-c cmd | file | -]
options:
-c cmd : execute program passed in as string
-d/--dump-vmcode: dumps vm bytecode to stdout
(only works in interpreter mode)
-b/--bytecode: runs file as bytecode
-a/--print-ast: prints ast and without run
-v/--version: version
```
## Examples
*see [/examples](https://github.com/ffwff/hana/tree/haru/examples) for more*
### Hello World
```
print("Hello World\n")
```
### Variables
```
name = "Alice"
age = 20
print(name, " is ", age, " years old.\n")
```
### Fibonacci numbers
```
// Regular recursive
fib(n) = n <= 1 ? 1 : fib(n-1) + fib(n-2)
print(fib(30), "\n")
// Faster recursive (with tail-call optimization!)
fibrec(n, prev, curr) = n <= 0 ? curr : fibrec(n-1, prev+curr, prev)
fib(n) = fibrec(n+1, 1, 0)
print(fib(50), "\n")
```
## Documentation
*see [DOCUMENTATION.md](https://github.com/ffwff/hana/blob/haru/DOCUMENTATION.md)*
## Building
(building was tested by using rust-nightly and gcc-4.8 on an x64 with Linux, mileage
may vary on other architectures)
Just do:
```
cargo build --release
```
## License
GPLv3 License