PureScript vs Rust

Has Typeclasses and RankNTypes

The Eff monad, which is used for FFI code, optimizes out calls to bind, and supports tail call optimization, resulting in clean, efficient Javascript. The psc compiler also specifically recognizes the ST monad, and transforms scoped variables into mutable Javascript variables, for even more efficient code.

Compiling should be your first unit test. A tight type system (static and hopefully strong) will catch many logic errors that are often difficult to spot through debugging. In languages like PureScript, if it compiles, it often runs properly.

You cannot have side effects, unless a function is explicitly defined as so.

Modules compiled to CommonJS can be included with 'require', making it incredibly simple to call Purescript code from Javascript.

FFI system is quite good and easy to use. You can import functions curried or not curried. Records and arrays use native JS objects and arrays.

The Purescript website has fairly thorough documentation for all of the language's features, and the Purescript blog contains several examples of practical usage.

Thermite (React)
Halogen (VDOM, similar to ELM)
And hit these up with Signals, Isolated/(Managed?) Components, powerful functions and FFI

Since Rust is statically typed, you can catch multiple errors during compile time. This is extremely helpful with debugging, especially compared with dynamically typed languages that may fail silently during runtime.

Rust uses LLVM as a backend, among other things this allows Rust code to compile down to machine languages. This allows developers to write programs that run as efficiently as possible.

Unique ownership system guarantees a mutable data to be owned and mutated by only one thread at a time, so there's no data race, and this guarantee is checked at compile time statically. Which means easy multi-threading.

Of course, immutable data can be shared among multiple threads freely.

You don't have to write same array and dictionary classes hundreds and thousands times for strong type check by compiler.

Rust has built-in support for concurrency.

Since Rust 1.8 you can install additional versions of the standard library for different targets using rustup/multirust.
For example:

$ rustup target add x86_64-unknown-linux-musl

Which then allows for:

$ cargo build --target x86_64-unknown-linux-musl

Rust is a modern programming language written around systems. It was designed from the ground up this way. It's language design makes developers write optimal code almost all the time, meaning you don't have to fully know and understand the compiler's source code in order to optimize your program.

Furthermore, Rust does not copy from memory unnecessarily, to give an example: all types move by default and not copy. Even references to types do not copy by default. In other words, setting a reference to another reference destroys the original one unless it's stated otherwise.

When you identify a part of your code which gets repeated often, which you cannot abstract using functions or classes, you can use Rust's built-in Macros.

Cargo is the official package manager for Rust. It comes with the language and downloads dependencies, compiles packages, and makes and uploads distributable packages

While not as verbose as Java, it still is much more verbose than languages like Go and Python. This means that the code is very explicit and easy to understand.

The biggest community contributing to language.

Very easy to create functional with some additional from structure application.