Rebo is an expression-based scripting language with syntax heavily inspired by rust. It is statically typed and has backwards type inference. When executing a script, rebo fully analyses and checks the source code including all types, before it runs. While that approach is usually used for AOT (Ahead Of Time compilers), the execution of rebo is interpreted and thus embeddable on all systems. This approach also allows defining types and functions after their first use.
- book / documentation: https://rebo.oberien.de/book/.
- playground: https://rebo.oberien.de/.
- Make sure to have rust installed. If you don't have it installed already, follow the guide on https://rustup.rs/.
- Clone this repository and navigate into the directory (
git clone https://github.com/oberien/rebo; cd rebo
) - Run a rebo file:
cargo run --release test.re
to be documented:
- rust-functions (struct / enum as arg / ret, methods, primitive-methods, generics)
- required rebo functions
- BoolNot has lower precedence than comparison operations
- intermediate method calls in assignments not allowed:
foo.get().bar = 5
doesn't work,let bar = foo.get(); bar.bar = 5
does - no expression-field/method-access - methods / fields can only be called / accessed on variables (not expressions)
- for example, you can't write
1.to_float()
but instead need to writelet i = 1; i.to_float()
- for example, you can't write
- no recursive patterns:
match foo { Foo::Foo(Bar::Bar(baz)) => ... }
- pathological format strings:
f"{f"{"{"}"}"
- bad unification of generic functions as first-class citizens
- unsure if multiple types on a typeck-node should be an error
- no proper garbage collection, just Arc (i.e. reference cycles will be leaked)
- generators
- destructuring:
let Foo { bar, baz } = foo
- non-duplicate field initialization:
Foo { bar }
instead ofFoo { bar: bar }
default()
Rng::gen()
- stdlib docs, autogenerated docs
- traits, generic traits, associated types, iterator-trait
- proper module system
- tuples:
(1, "foo")
- generic wildcard
- proper ranges
- forbid or implement never-type and varargs
- proper mutability
- unused warnings: struct-fields, enum-variants, bindings, functions
- casing warnings: statics, binds, functions, types
- int bit-ops (and, or, xor, -assign)
- detect and error against circular static instantiations:
static FOO = BAR; static BAR = FOO
- improve bottom-handling in typeck (
Constraint::PropagatingBottom
):fn foo() -> i32 { return 42; }
- Regex caching / interning
- String interning / Cow / &str optimization
- fix existing unit tests and add more
// shall not ICE - shall result in UnknownEnum diagnostic
match field {
Foo::Empty => (),
}