Tracking issue for new features

[schungx]

pre 1.0

• string interpolation (String interpolation #121)

1.0

• futures (Futures #52)
• basic threads (threads #36)
• advanced threads + actors (Advanced threads and actors #32)
• formal grammar and formal parser (Tighten parser #4)
• rudimentary error recovery (Poll: Better error recovery? #119)
• rudimentary type checking (Type checking #117)
• compiling to byte-codes (Bytecodes #161)
• reverse-format an AST back into code (why would anyone want this?) - if this can be pretty-printed, then we can have a rhaifmt formatter.

closed

• stdlib opt-in (Tiny opt-in standard library #27) closed by General code clean-up and improved documentation. #104
• throw errors (Runtime Error Handling: A Minimal Proposal #78) closed by General code clean-up and improved documentation. #104
• support minimal builds (for size) via turning off language features closed by Add opt-in features to turn off/disable language features. #106
• support constants closed by Constants and aggressive optimizations. #108
• no-std (How to use with no-std #19) closed by Add no_std support #103
• eval closed by eval #110
• evaluate expressions only (Evaluate expressions only #113) closed by Add evaluate expressions. #114
• objects (objects in rhai #73) closed by Add object maps. #120
• Send + Sync (Engine is neither Send nor Sync #91 ECS? #95) closed by Send+Sync #123
• in operator (in operator. (was: can Any::downcast_ref be public? after upgrading rhai it's private now) #124) closed by Reentrant Engine, Rust anonymous functions, in expression, timestamps, bug fixes #128
• export anonymous functions to Rust (Support anonymous functions #11) closed by Reentrant Engine, Rust anonymous functions, in expression, timestamps, bug fixes #128
• arbitrary number of indexing levels within a dot-setter chain for assignments (right now only supports one level of indexing) closed by Packages and general speed increases (esp for arrays and maps) #144
• optimizing the AST to improve evaluation speed and reduce memory footprint closed by Fixes and cleanup plus an optimizer. #105 Constants and aggressive optimizations. #108 Constants and aggressive optimizations. #108
• modules (Modules schungx/rhai#7 Modules? or #include? #122) closed by Modules and speed improvements #150
• indexer support for custom types closed by Modules and speed improvements #150
• custom operators (Custom operators and custom syntax #166) closed by Serde support, disable keywords, custom operators, custom syntax and chainable API. #176
• serde support (serde support for Dynamic values #174) closed by Serde support, disable keywords, custom operators, custom syntax and chainable API. #176
• ruggedization - no script should ever be able to panic the whole system (Make Rhai rugged #102)
  • checked math Fixes and cleanup plus an optimizer. #105
  • guard against stack overflows due to infinite recursion Efficiency improvements and code refactor. #116
  • guard against infinite loops, limit on operations count Limiting script resources #154
  • protect against panics during parsing Immutable strings and built-in common operators #156
  • protect against really deep expression trees which may overflow the stack Immutable strings and built-in common operators #156
  • protect against over-sized data Minor refinements and enhancements, WASM. #163
  • check script run progress and ability to force-terminate script run Limiting script resources #154
  • disable certain language keywords Serde support, disable keywords, custom operators, custom syntax and chainable API. #176
• better documentation (documentation #37, Documentation!() #15)
  • Fixes and cleanup plus an optimizer. #105
  • more cleanup Constants and aggressive optimizations. #108
  • even more cleanup no-std support #109
  • use mdbook to convert the README into The Rhai Book
• Builder-style API to setup Engine and environment (How to use with no-std #19 (comment)) closed by Serde support, disable keywords, custom operators, custom syntax and chainable API. #176
• Unicode Standard Annex Ranges, rustic for loop #31 Identifiers (unicode-xid support for identifiers. #204) closed by New unicode-xid-ident feature to allow unicode-xid for identifiers. #205
• first-class functions and closures (First-class functions and closures support #159 )
  • poor man's OOP closed by OOP support #172
  • anonymous functions (Structural data construction and anonymous functions without closures #175) closed by Anonymous functions, no-std fix, simplify custom syntax, minor speed improvements. #188
  • currying closed by Function pointers currying. #189
  • full closures via automatic currying and sharing closed by Closures. #206
• Plugins system closed by Plugins. #229
• benchmarks (Benchmarking Rhai #101)
• Rhai playground (Rhai playground (using WebAssembly) #169)
  • prototype playground: https://alvinhochun.github.io/rhai-demo
• persistence of AST format? Useful? It may be easier to just persist the script... - won't fix
• ++/-- operators (Decide on increment/decrement (++/--) operators #30) - won't fix
• more numeric literals for different sizes/signed (Support more number literal types, including floating point #2) - won't fix
• try-catch closed by Add try-catch. #265

[luciusmagn]

Oh wow, there's been a lot of neat development that eluded my sight. That's awesome :D I'll see if I can help with some of these in the future!

[schungx]

Kudos to the team that laid all the superb groundwork beforehand!

[schungx]

I'm probably spending way more time on this than I really should... but...

it seems like the language is at a reasonably stable state with most of the low hanging fruits already picked. To speed up Rhai further will really require some hefty architectural changes, time for which may be productively spent on implementing other useful features instead.

So... what feature do you fancy to be added to Rhai next?

I would probably pick one of the following:

• first-class functions and closures
• string interpolation (and maybe overhaul entirely the way strings are handled, or mis-handled right now) - but do people really use Rhai for heavy strings-manipulation?
• threads/fibers/actors? coroutines?
• go-for-it: byte-codes. I profiled a number of benchmarks and it seems like most of the time are now spent in eval_expr and eval_stmt as predicted. there are no more low-hanging fruits...

[vi]

Is version 1.0 (or next intermediate semver-incompatible version) a good chance to fix Cargo features to be positive instead of negative?

[schungx]

I am still divided on this - on the one hand, it may break a lot of existing code. On the other hand, it conforms to "standard".

I think I'll let the community ponder it more before deciding to change it for 1.0...

[Eliah-Lakhin]

@schungx Personally I would vote for this one:

first-class functions and closures

Even having first-class functions without closures would be very good. This is something I need to make structural data constructions more concise in my project that is using rhai extensively.

I would suggest a syntax in a form conformed with Rust, so something like |x, y, z| (x + y) / z and/or |x, y, z| {let sum = x + y; sum / z}.

Will be happy to help with this implementation if you need more hands. LMK. Thanks!

[schungx]

Actually I've already put in place all the mechanism needed to parse the closure syntax.

The current idea is |x, y, z| expr will create an anonymous function based on the hash of the function body. Say it is fn $abcdefg1234567$(x, y, z). Then it will replace the closure with Fn("$abcdefg1234567$").

Then other than not being able to capture the running environment, this will look almost like standard OOP.

[schungx]

Anonymous functions (not closures) support already in, together with the ability to curry a function.

[schungx]

Full closures with capturing merged in.

This is thanks to the work of @Eliah-Lakhin

[Eliah-Lakhin]

And I want to say thank you to @schungx for his great work in development and maintenance of Rhai! Without his help in stabilizing of my prototype and implementing of other related features it wouldn't be possible to deliver this feature that fast.

Rhai in my opinion is the most promising and well maintained embedded scripting project in Rust ecosystem.

[schungx]

Plugins system (powered by procedural macros) merged in.

Thanks to @jhwgh1968

Documentation: https://schungx.github.io/rhai/vnext/plugins/index.html

[schungx]

A minor new feature lands: try ... catch statements.

https://schungx.github.io/rhai/vnext/language/try-catch.html

A try block catches most catchable errors, other than non-catchable ones... well...

The particular implementation technique of treating return values and loop breaks from the very beginning of this repo translates well to implementing this, which took very little time and very little code for perhaps a high impact new language feature.

[schungx]

Deprecating this list in favor of new feature requests as new issues.