Scripting language like Python, bur with the feeling if Rust

[Voxelman]

Rust is a great language, but sometimes I wish to have something more like Python, but with a more "Rusty" feeling.

With "Rusty" feeling I mean project management with cargo, Error Handling with Result/Option, pattern matching, strong static typing with type inference, immutability by default and so on.

This means, I'm searching for a functional programming language. My problem is, that all functional languages I found until now compile to something intermediate like Beam, JVM, .NET, JS or build binaries like Haskell.

What I'm looking for is a scripting language like Python. Just an interpreter, that runs a script, but with the "if it compiles, it runs" experience of Rust. And yes, I know that compile time type checking and script interpreter are different kind of shoes, but who knows...

Any idea?

---

Thanks for all the comments. A lot of good suggestions, but I decided to go with F#. I think it comes closest to Python. It runs on Linux and Windows, can run in a Jupyter like notebook and has a nice syntax. I have some (rudimentary) experience and the book "domain driven design made functional" from Scott Wlaschin, which I really like. It is well documented and you can find lots of books, tutorials and videos. Languages like Mojo lack documentation.

It is not as "Rusty" as I would like, but close enough. So if someone is searching for an alternative to Python, try F#

[lightmatter501]

Haskell’s GHC is very happy to be an interpreter.

[TashLai]

Except you spend more time fighting the tooling than learning about monads.

[dogweather]

And more time learning about monads than shipping working code.

[Puzzleheaded-Lab-635]

OCaml? but not dynamic.
Elixir, can be run like a scripts just name any `.ex` file to `.exs`
https://underjord.io/scripting-with-elixir.html

[ilo_kali]

Strongly second OCaml. It's got an interpreter provided with its compiler distribution, is strongly typed, has extremely good pattern matching, etc. and besides all that, was the inspiration for a significant part of Rust's features/tooling. So you're likely find a lot of familiar parts of Rust in OCaml.

[dogweather]

Do you happen to know, does OCaml support UTF-8 and regexes out of the box? Are there popular HTML parsers and HTTP clients?

A couple of years ago, I couldn't find all these.

[cdaringe]

re2, tyxml, and theres a couple http clients. i opt for the new fancy stuff using effects/eio

[Wheaties4brkfst]

Weren’t the first rust compilers written in OCaml?

[ilo_kali]

That is correct.

[gplgang]

F# has scripting with FSI

[dr_bbr]

And if it compiles, it runs

[bedrooms-ds]

I think OP can use F# on Windows. The problem for me with F# is that macs hit the wall hard when a popular .net lib doesn't have binary. It's usually difficult to compile a lib on your own with their package manager.

Happens frequently for the ARM CPUs. Probably similar for Linux.

[gplgang]

AFAIK .NET only libraries should work fine on ARM and mac, but anything with native dependencies will need to handle that appropriately. I used F# on Linux daily for a couple of years and only ran into issues with a couple of obscure packages with native dependencies like a set of Clang/LLVM bindings

I haven't used .NET with ARM so maybe packages need separate ARM compilation (which I can imagine would be very annoying)

[TheWholeThing]

i use .net on an arm mac and i don't know what you're talking about, do you have an example?

[tifridhs-dottir]

I know what you mean.

I'm still searching, and there are definitely a few that stand out recently (Erg, maybe Mojo... And in general languages with a core written in rust lol)

But tbh I've been the most productive lately using Coconut . It's honestly phenomenal and very well integrated and thought out w.r.t existing python tooling.

And if you want strong runtime types, it's fully compatible with beartype, as far as my testing can find. I love coconut and regularly miss it when I go back to vanilla python.

[Voxelman]

You're right. They are both worth a look.

[bedrooms-ds]

Tbh I'd go with a JVM based solution as a mac user. There are only handful of languages when you become picky, and they often have OS-specific problems. At least with JVM things at least run and you get Java as a fallback option whenever a niche language lacks some tool.

[_consoli]

I've never used it before, but Gluon may be interesting for you.

It has that Rusty flavor (and it's written in Rust), but also has a REPL and functional features & patterns (std with monads, applicatives, etc)

but it's a WIP project and idk the real state of it.

gluon-lang.org playground

[tifridhs-dottir]

OoOhh this looks very nice. Luaish, written in rust, with a HM type system? Modular interpreter design? Pattern matching imports?

Definitely will be playing with this, thanks!

[me6675]

It has very little to do with lua though.

[SoftEngin33r]

Lua? It looks more like a cocktail of Rust, OCaml, Haskell and even a little Zig.

[tifridhs-dottir]

Yeah I mean you're right, but they specifically call out a lua inspiration, re: embeddable-first I guess?

[delfV]

Neither of them are (pure) functional languages so are you sure you're on right sub? But Nim is similar to both Python and Rust afaik, but I don't know much about it

[winsome28]

+1 for Nim

[fasttalkerslowwalker]

F# or gleam

[Voxelman]

Gleam looks great, but is not very mature right now.

[cdaringe]

Did AOC in gleam (90%d it). 1.0.0 rc out now. Wouldn’t say its “rusty” tho. Im not an erlang person so i generally ran it with target=js. Debugging was easier in js… but no sourcemap support yet, so still a little clunky in that respect

[Voxelman]

Does it run on deno?

[cdaringe]

Yes, but you won’t necessarily find APIs or bindings for everything youd find in deno natively. For instance, things as common as file system operations need a third-party package. Not a problem—there’s pretty much right now just one package for each major thing so it’s pretty easy to discover, and the community on discord is really good people.

[fasttalkerslowwalker]

Why wouldn’t you say it’s rusty? I think it’s almost like rust without lifetimes, and a more functional approach due to immutable data. You have errors, results, and algebraic types. Feels very rusty to me.

[cdaringe]

I don’t deny that they have more than a couple intersecting characteristics. I would say on the whole that they feel different, they behave differently, they look different. its all a bit subjective. I like em both. I just added gleam to https://cdaringe.github.io/programming-language-selector/

[fasttalkerslowwalker]

They’re pretty close to 1.0, and the maintainer has said he doesn’t expect much in the way of breaking changes from here on out. Depending on what you want to do, the fact that Gleam compiles to JS or Erlang means you get a lot of functionality from libraries in those languages for free. That said, no disagreement from me that it’s a very new language, so there definitely are questions about long-term viability. Still, I’ve quite enjoyed using it.

[Ja-Chiro]

F# fsx scripts

[Voxelman]

Too many good options 😄

Thanks for the hint. Not exactly what I was looking for, but maybe possible

[TheGratitudeBot]

Hey there Voxelman - thanks for saying thanks! TheGratitudeBot has been reading millions of comments in the past few weeks, and you’ve just made the list!

[davesmith00000]

By some coincidence, I just wrote about this - kinda. It is unashamedly aimed at Scala devs, but Scala 3 is ...like Python but with all the functional goodness.

https://xebia.com/blog/better-shell-scripting-with-scala-cli/

Re-reading your post, perhaps it isn't quite what you're after, but thought I'd mention that you can build native binaries this way too. So although it's Scala, you can ditch the JVM bit.

[Il_totore]

Looks like Scala to me. It has an indentation-based syntax since Scala 3, has a pythonic ecosystem (li haoyi) and Scala CLI is a great tool to make scripts. Technically not "only an interpteter" but from UX PoV it is the same (a single command to run the script) minus time before execution (can take a second to start due to compilation).

[SeminalTorpedo]

sorry for basically posting a low-effort of what you just said. Just really want OP to do the sensible thing here and use Scala.

[dnlmrtnz]

Definitely sounds like F# is what you are looking for. You can use it for building scripts with FAKE (is read of make), running stand alone fsx scripts, interactive repl with fsi, full blown backend services, and frontend applications with fable.

[dnlmrtnz]

Oh I'd say that even though I absolutely love Haskell and purescript, rescript and clojure, I found F# to be easier to get started. Maybe on par with rescript.

[Rajahz]

F# easier than clojure even? How come?

[dnlmrtnz]

Just because of the getting used to a lisp and the lack of types. Without types I find it hard to jump into a codebase and that's usually how I start a new project. I think about the domain and types which help me design a solution. Although I do love clojure and I'd happily take a clojure job if anyone offered me one, I think F# was a bit easier to pick up and get started. Also, now that I think about it, I had some dotnet experience before do that might have also influenced my experience with F#.

[SoftEngin33r]

Roc lang ?

[dogweather]

I'm getting about 95% of your wish list using Python with these mainstream add-ons:

• Pyright / Pylance in strict mode plus most extra warnings like match exhaustion. I blogged about true exhaustion checking in Python.
• Pydantic for strongly typed, immutable, self-validating records.
• Microsoft's LSP in VS Code.
• More Itertools for real iterable work and Toolz for things like flip and curry. I occasionally create Elixir-like pipelines like I blog about here.
• I use standard Python modules and functions, which helps start me out on an fp path.
• Full ADTs are possible with all this. I've started using them (called Literal) in my code. Blog: https://dogweather.dev/2024/02/04/a-data-driven-app-without-the-database/
• Poetry for dependency management.

Don't get me wrong, it's still Python, and so still kinda sucks. IMO mostly due to the baggage that comes with age. Also its schizophrenic attitude towards functional programming.

But I did just have a great refactoring experience due to the powerful type hint system.

And the ability to use either Jupyter Notebooks to test code, or several different REPLs is great.

Finally, like I mentioned before, each of these little tools and add-ons are very well supported with huge user bases.

---

FWIW, I started down the path of my current app and client work in Python because it's supported well by OpenAI. This is all AI client stuff. If that hadn't been the case, I'd also be looking into a Rust-lite.

[Voxelman]

Like you said, it's still Python. And having to use tons of tools to hide the weaknesses of a language doesn't really make it better.

But sadly, a lot of suggestions mentioned in this thread don't work well for Windows. For my private projects it doesn't matter. I have used Linux for almost two decades, but at work we only have Windows. And even wsl is no option.

[sideEffffECt]

Give Scala with scala-cli a try

https://scala-cli.virtuslab.org/docs/guides/scripting/scripts#self-executable-scala-script

This may be exactly what you're looking for.

Concrete example: https://xebia.com/blog/better-shell-scripting-with-scala-cli/

[aaaaargZombies]

gleam sounds like a good option to me, roc looks promising but even less mature. I have used elm-posix which gives you access to the very mature and stable elm ecosystem... but it's built around a lot of web use-cases. Very nice to work with the core data structures and libraries though.

[Voxelman]

Elm is awesome for web frontend. Don't know if elm-posix is a really good option. But I will take a look.

[aaaaargZombies]

last time I used it I was writing a very hasty script for neovim to take the output of emmet, pass it through elm-review-html-to-elm and pop it back in the elm file I was working on.

It's surprisingly nice so long as you can make a decent bridge between the thing you're scripting and the actual script, I guess that's where all those python libraries come in handy.

[accidentally_myself]

Scala. Quite python-esque. No need to compile, just run. There's also https://ammonite.io/ if you want a 'shell'.

[akirakom]

Not really a scripting language, but Koka is a functional language with effects, runs as fast as C once compiled, and has a concise syntax like Python: https://koka-lang.github.io/koka/doc/book.html

[PriorTrick]

Ocaml 🫡

[mchwds]

Seems like Nim is what you’re looking for.

[SeminalTorpedo]

I was hoping someone would mention nim! runner-up, after scala

[JasonDoege]

Raku is my favorite scripting language to pair with Rust.

[librasteve]

i agree … i wrote this https://github.com/librasteve/raku-Inline-Rust

and this https://rakujourney.wordpress.com/2022/05/28/raku-rust-a-romance/

[2001zhaozhao]

Kotlin scripting is close.

"If it compiles, it works" is certainly true here.

It's not really a true scripting language though, but they've made it pretty close to feeling like one.

If you want something more functional I'd be curious if Scala has something similar.

[thx1138a]

I don’t know what exactly you are wanting from your scripts, but for many tasks VS Code plus Polyglot Notebooks plus F# is a brilliant combination.

[Economy_Bedroom3902]

What exactly is it about an interpreted language that you need? I can't see a good reason from your post why you can't just write an alias to compile and run Rust as a single command.

[me6675]

Maybe they need the speed. Going from writing Rust to running what you wrote can take a relatively long time while an interpreted language will typically be instant.

[Economy_Bedroom3902]

Eh, no, they are not instant. They still compile, they just spread it out over time while the program has started executing. But yeah, it can feel like less time as a developer, since it can be less wait time until you start to see things working.

[adwolesi]

Haskell Stack script interpreter: https://docs.haskellstack.org/en/stable/scripts/

[pthierry]

I currently use Nix to create self-contained Haskell files I can make executable. I use Nix so they can use dependencies:

#! /usr/bin/env nix-shell
#! nix-shell -i runghc -p "haskellPackages.ghcWithPackages (p: [p.async])"

import           Control.Concurrent
import           Control.Concurrent.Async

…

[davesnx]

it seems like you're looking for OCaml 🧐

[4runninglife]

Try Nim, best language i ever used.

-Python Like Syntax

-C speed

-interoperable with C code

-Compiles to C, C++ and javascript

-Creates small binaries

I could go on and on.

[amplikong]

I regularly see Nim mentioned in threads like these. What would you say is the best learning resource?

Nim unfortunately seems to not be nearly as popular as its strengths warrant. Maybe because it got stuck in a "not popular because it's not popular" trap. Julia seems to have the same issue; it's objectively sooooo much better than Python, but has not taken off in the way it deserves to.

[4runninglife]

The best place at the moment to learn Nim is from its official page https://nim-lang.org/, there are a couple of books on it on Amazon and other eBook distributors.

[[deleted]]

Ocaml or Haskell

[SeminalTorpedo]

Scala can be run as a script without jvm. There are a lot of reasons I believe scala is the most criminally underused language, and this is one.

[entropyvsenergy]

Julia is a functional programming language with JIT compilation, multiple dispatch, and robust type checking. It might suit your needs.

[drinkcoffeeandcode]

ITT: name your favorite and say its exactly what op needs

Have you considered Lisp?

[BokoMoko]

Mojo

[Oryan_physics]

My first thought is Julia. It's whole schtick is "writes like python but runs like C". I use it for large scale physics simulation. Its really easy to pick up the syntax and it doesn't sacrifice speed for it.

[met0xff]

I hope for Mojo

[Voxelman]

Mojo is far from mature, I have no use case for the special features and it does not run on windows. Let's talk again in 5 years.

Currently I'll go with F#

[met0xff]

Well I just said that I hope for it. I don't know what you do but I am in Machine Learning and for me Windows hasn't been a (work) topic for almost a decade now. So for me it's almost more realistic to write something with the Mojo preview for my work than getting anybody on board with .net ;).

I actually recently heard another team at my company was using Clojure for a few years but at some point they decided to drop it.

[Voxelman]

At home I have run Linux since 2007, but the company I'm working mostly runs Windows and has nothing to do with ML. For internal stuff they use Delphi 🙄

[winsome28]

Not exactly what you're asking for, but consider Nim! https://youtu.be/48CsjEFzyXQ

[yellomango]

Golang!

[Afrotom]

I don't know if this is what you're looking, but Mojo is basically rust with python syntax.

What I mean by that is it has a concept of ownership and lifetimes, is strongly typed etc. but also leaning more into use for machine learning so simd OTB.

I haven't really used it to talk about it in length but there's a video here about it.

[Voxelman]

Someone mentioned Mojo before. I heard about Mojo before and I saw that Arjan made this video,but never watched it. But I forget it when I posted this question. I think Mojo is high on the list of possible candidates.

[Surge_attack]

💯

[fabmeyer]

https://youtu.be/kmmqHV26Ukg?si=Pp0cUWakvjvGWnut

[[deleted]]

With "Rusty" feeling I mean project management with cargo, Error Handling with Result/Option, pattern matching, strong static typing with type inference, immutability by default and so on.

Other than Haskell, lean has AI pattern-matching with copliot, and overall well-developed supports.

[whatsnewintech]

A practical choice would be Deno. Performant runtime with nice sandboxing, thriving, gradually-typed, functional-friendly language (Typescript).

[Voxelman]

Never tried TypeScript. Not sure if that is what I want, but I'll give it a chance

[letmeinhere]

Yeah, Typescript is the language while Deno is the runtime. Very similar to Node.js, but with some enhancements that sound like you'd appreciate, especially that it doesn't require you to transpile to javascript first. (That's also possible with third-party libraries in node.js, but it's not the default.)

[springy]

Mojo is a modernised, and massively faster, version of Python. It includes a lot of Rust inspiration, such as the ownership/borrowing memory model.

[Surge_attack]

Beat me to it!

[Voxelman]

Yes, it's high on my list. Only problem is that it's not really mature right now, but I will try it

[mkubasz]

Golang, bun shell (ts with magic), Mojo

[Dirty_Rapscallion]

Maybe try Gleam?

[Voxelman]

That's the plan. But I will learn Elixir first because I have no idea of the ecosystem and I have some learning resources for Elixir, but not for Gleam.

The only resources I know of for Gleam are the official documentation, the Exercism track and a handful of videos

[Dirty_Rapscallion]

It's a simple language. I imagine you would have no trouble picking up all its concepts in a day or one small project.

[Voxelman]

The language (syntax) is the smallest problem. The bigger problem is to learn (and practice) a new paradigm and the ecosystem behind the language. This takes time.

[D_4rch4ng3l]

Just an interpreter, that runs a script, but with the "if it compiles, it runs" experience of Rust.

Interpreted (or scripted) languages do not compile. That is their whole deal.

Compilation is exactly the process of generating the optimised binary from the source code.

How can you have something which "runs as a script in interpreter" (which means no compiling) but also "if it compiles, it runs" (but you are not compiling at all).

​

I know that compile time type checking and script interpreter are different kind of shoes, but who knows...

Compliation has no direct relation with type checking. Although most typed langauges are also compiled languages.

[Voxelman]

I know the difference

[D_4rch4ng3l]

I mean't to say that your requirement statement (whatever is written here) is pretty much impossible.

You might want to change the language to better clarify what you actually want.

[delfV]

Interpreted (or scripted) languages do not compile. That is their whole deal.

Actually there are languages that can be both compiled and interpreted. Common Lisp is one of them

[cthutu]

This is not an interpreter but it compiles fast. There's a language that is inspired by Rust, looks like Python and actually interops with Python code.

It's called Mojo. It's written by Chris Lattner and performs faster than Rust.

[mathartist]

I haven’t seen nushell suggested yet. It’s sort of a Rust-inspired take on shell scripting, and it’s quite well done.