Rune as a stand alone language

[wmiller848]

Greetings,

First off I have been enjoying Rune very much since I came upon it. Excellent design and enjoying the inspiration from Rhai. Likewise in some small benchmarks I've ran against Ruby I was very impressed with the performance of Rune given it's age and scope. I really enjoy Rust both in design and its syntax, but that said there are times when dynamic languages have some advantages.

My question here is what is the appetite to provide some more infrastructure to flesh Rune out as a fully stand alone language as well as an embeddable one? Namely expanding the std lib and creating a package / source manager for Rune, naturally written in Rune. I'm sure there are other considerations such as stability, performance, etc.

I took a brief stab at adding an "env" module to include some basics like getting command line args, env vars, etc. In playing with Rune it got me curious what Runes contributors are interested in.

Thanks

[udoprog]

Hi! Thank you for the kind words!

I'd be happy to incorporate tools to allow the use of Rune more conveniently as a standalone language. All though since this is not my primary use case I don't feel comfortable driving it. Ideas and contributions are very much welcome!

Note that some minor infrastructure was added in supporting manifests (see Rune.toml) which almost wholly resides in rune-cli. More things can be added here. Another thing that is "missing" are declaration files for native modules. Without which we can't generate documentation (see #73).

naturally written in Rune

My thinking is that everything that can be written in Rust probably should be. And a hypothetical package manager is no exception (see the discussion around juliaup). There's little benefit to be gained from using Rune there, and since Rust is already a dependency for building it and is so awesome it's the natural choice.

[wmiller848]

Interesting, so one of the immediate things I noticed was the current rune-cli bin is more geared towards debugging and testing. Its multiple source paths was also a bit odd. Accepting the multiple path args and passing args to the rune program proved difficult and I took a few stabs at changing rune-cli to preserve the multiple path behavior and get something ergonomic but came up empty.

Ruby

Example Ruby Script:

#!/usr/bin/env ruby
# hello.rb

puts "Hello Word #{ARGV}"

$ ruby hello.rb
Hello World []

$ ./hello.rb
Hello World []

$ ruby -W0 hello.rb --flag
Hello World ["--flag"]

Rune

// crates/rune-modules/src/env.rs
fn args() -> rune::Result<Vec<String>> {
    Ok(env::args().into_iter().collect())
}

#!/usr/bin/env rune run
// hello.rn
use std::env;

pub fn main() {
  println!("Hello World {:?}", env::args()?);
}

$ ./hello.rn
Hello World ["rune", "run", "./hello.rn"]

$ rune run --warnings hello.rn --flag
error: Found argument '--flag' which wasn't expected, or isn't valid in this context

$ rune run hello.rn -- --flag
Hello World ["rune", "run", "hello.rn", "--", "--flag"]
Error: cannot read file: --flag
Caused by: No such file or directory (os error 2)

rune run --warnings hello.rn -- --flag
Hello World ["rune", "run", "--warnings", "hello.rn", "--", "--flag"]
Error: cannot read file: --flag
Caused by: No such file or directory (os error 2)

From what I gather from your link to juliaup and comment you're keen on leveraging rust for the package manager which I think is fine, maybe a bit more customary for a language to self host their package manager but I can see it both ways. The main advantage of writing a rune package manager in rune isn't performance though, its dog-fooding the language and will instantly result in large expansion of the std lib to accommodate a non-trivial program. I recognize Rune is a bit different here as none of the languages listed bellow started off life as dynamic scripting language designed to be embedded in a strongly typed language. To that end having the package manager in rust would make it easier for programs embedding rune to inter-op with.

Each of these are written in their respective language.

https://github.com/pypa/pip
https://github.com/rubygems/bundler
https://github.com/crystal-lang/shards

Regardless of what is written in what I think to move Rune forward to supporting stand alone it needs

• The rune-cli or another bin to facilitate more command line driven ergonomics placing the target rune program as the primary benefactor
• A package / source manager
• Expanding the std lib

Sorry for being a bit repetitive with this list but it sounds like the project is open to contributions that could move these goals forward while still maintaining its ease of embedded use cases. :)