# Openbirch Rust

Openbirch rewritten in rust.

Very messy and bad, im gonna start the umpteenth rewrite soon.

# Features

[x] Constants (numbers)
    [x] Addition
    [x] Subtraction
    [x] Multiplication
    [x] Division
    [x] Arbitrary float precision
[ ] Sets (or lists, arrays, etc)
    [x] Definition
    [x] Multiplication with constants
    [x] Concattenation
    [ ] Index operator
[x] Functions
    [x] Native functions
    [x] User defined functions
    [x] Currying
    [x] Closures
    [x] Calling
[x] Scopes
    [x] Shadowing variables
[ ] Ranges
    [x] Defining ranges (`1..5` is a range of `[1..5)`)
    [ ] Iterating ranges
    [x] Evaluating ranges (very hacky, but defining a Set of length 1 with a range expands said range into the set, eg `[1..3]` becomes `[1,2]`)
[ ] Loops
    [x] Infinite loops (`loop ... end` block)
    [ ] For loops (`for x in y ... end` block)
    [x] Break keyword
[ ] Match expression
[x] If expression
    [x] If expression
    [x] If-else expression

## Wanted

[ ] More concise syntax, i dont like how it is right now
[ ] Fix stack overflow with recursive functions (internally convert to loops)
[ ] Generally implement more 
[ ] Implicit multiplication (may not be possible to implement non-ambiguously)
[ ] Differentiation
[ ] Integration
[ ] Better error handling (i was lazy and skimped on errors, bad move)

# Syntax

Every Openbirch program is made up of 0 or more *expressions*.

An expression is anything from a binary operation like `2+2` to function calls `f(x)` and
even assignments `x := 5`.

All expressions return a value. For expressions that "dont" they return an `Empty`, which cant
be used for anything and will error if used in other operations (eg. `2+{Empty}`).

## Definition

Variables can be defined with a `define` expression.

```
x := 5 # define x as 5

print(x+x) # prints 10
```

As openbirch is a symbolic language variables can be used before assignment

```
y := x^2

print(y) # prints x^2

x := 5

print(y) # prints 25
```

### Scopes

Some expressions define a *scope*, where all defined variables inside will be deleted once the scope ends.

Expressions that create a scope include, but are not limited to,
- If-else
- Loop
- Functions
- Closures

If a variable is defined outside a scope it will be *shadowed* inside the scope. What this means
is that inside the scope the variable will have the shadowed value, while outside the scope it
will have the previous value.

```
x := 5 # Global scope

print(x) # prints 5

if true then    # Define a new scope
    x := 5000 # Shadow the value of x
    print(x)  # prints 5000
end             # Scope ends here

print(x) # prints 5
```

### Assignment

Since you may want to change the value of a variable outside the current scope you can use an `assignment` rather than a definition.

```
x := 5

if true then
    x <- 500 # Assign to x rather than defining it and shadowing it
end

print(x) # prints 500
```

## If-else

If expressions are defined as such

```
if {condition} then
    # 0 or more statements
end
```

and if-else as

```
if {condition} then
    # 0 or more statements
else 
    {expression}
end
```

Since `if` is an expression the body of the else branch can be another if expression, in which
case only 1 `end` keyword is needed.

```
if {condition} then
    # 0 or more statements
else if {condition} then
    # 0 or more statements
end
```

Since all expressions evaluate to a value the value of the if expression is the resulting value
of the last statement in the chosen branch, eg.

```
x := if true then
    # Evaluate some expressions
    2+2
    f(x)
    y := f(f(x))
    # Last expression is returned
    5
else
    0
end

print(x) # prints 5
```

if a branch is empty then `Empty` is returned.

## Loops

Currently the only type of loop is an infinite loop.

```
loop
    # This will repeat forever
end
```

# Running

## Linux

```sh
$ cargo run
```

### Nixos

```sh
$ nix develop
$ cargo run
```

## Windows

idfk, havent used that shit in years, but probably just `cargo run`.

## MacOS

never used, but again probably `cargo run`