cargo-script-mvs VS cargo-script

The eRFC was intentionally light on details so the Pre-RFC / IRLO thread and the demo best reflect what we hope to accomplish which are pretty detailed as-is.

> A) is easy to write one off scripts that do a job fast, with minimal thinking and effort. I am thinking of Python and Ruby. For me I can write code with high velocity in these languages.

Once I wrap up some other projects, I plan to explore this space a little bit within Rust.

imo the biggest bang for the buck is just having good `#!` support. Probably mid-year I expect to have a Pre-RFC up for single-file cargo packages. See https://github.com/epage/cargo-script-mvs/discussions/15.

A bigger effort is a batteries included, non-zero cost stdlib. I've started writing up my thoughts at https://github.com/ergo-rs/ergo.

For more background on why I think these are important, see https://epage.github.io/blog/2021/09/learning-rust/.

Would love feedback on these ideas and other ways to make Rust easy to use without sacrificing what makes Rust it is.

This is something I'm interested. Every time I write a bash or Python script, I think "why didn't I do this in Rust?". The first barrier is in the same line as your thoughts which is why I've been investigating the various cargo-script spin-offs and working towards an MVP for a Pre-RFC.

Something I've been thinking a lot about for Rust is what can and should a REPL experience be for a compiled language (ie what are reasonable compromises).

There seem to be two repls that haven't gotten much traction:

- https://github.com/google/evcxr/blob/main/evcxr_repl/README....

- https://github.com/sigmaSd/IRust

There have been little and big nits that have held me back from wanting to push these further, including

- Bad defaults (having to opt-in to panic handling)

- Command syntax feeling out of place and likely not beginner friendly

- Limits on variable preservation

- Lack of introspection (at least irust as `:type`)

So far I've been punting on wanting to improve this area by instead focusing on polishing up a rust script solution in the hopes of getting it merged: https://github.com/epage/cargo-script-mvs

rust-script is the most up-to-date version I could find. See https://github.com/epage/cargo-script-mvs/discussions/15

cargo-script has been forked or reimplemented several times.

cargo-script: I've done some initial analysis and recorded my thoughts on what cargo-script in Rust should look like. If people are interested in this or other individual / company on-boarding improvements, I'd love to talk!

Fully agree with this though I also feel there is room for experimentation and improvement in this area. I've previously blogged on this and have started researching cargo-script. Hopefully later I'll get to my standard-adjacent library.

Accept BTC, all credit card * $1 .unwrap() - wallhack through Err * $2 .ok() - invisibility cheat for unused Result warning * $5 .unwrap_unchecked() - advanced wallhack, never fall out of map from panic For script console, just $10.

You can also use cargo script. After installing it you can just do

I think there are some projects in this area, eg, https://github.com/DanielKeep/cargo-script. For my personal scripts, I have a single Cargo.toml for a busy-box style multiplexed binary: https://github.com/matklad/config/blob/f0259ca8a3755f2e62a3bf472c2514fd6cb891ff/tool/src/main.rs#L16.

O seems that this does already exist: https://github.com/DanielKeep/cargo-script

You don't have to set up a project if you use cargo-script

Take a look at cargo script. That should/could do what you want

when I first started using rust, I knew python a lot better so I would write scripts with python. at this point though, I write a lot more rust than python these days, so I'll write pretty much everything with rust. cargo-script is a useful tool for this, as well as the self-compiling script: https://neosmart.net/blog/2020/self-compiling-rust-code/

Another option is cargo-script, which lets you run self contained rust files.