openbirch-rs/README.md

# 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`