Ah, now you're talking my language. 🙃

Well, for one you're forgetting the main():

fn main() {
    println!("Hello, World!");
}

Then Rust already has syntactic sugar to omit the Unit-return-type, so it's really:

fn main() -> () {
    println!("Hello, World!");
}

And then Rust decided to make println!() blocking. It could also look like this:

async fn main() -> () {
    println!("Hello, World!").await;
}

async is what the ' in Unison is. I guess, because it is so commonly used in Unison.

And Rust decided, if the println!() fails, then panic!(). But I can see merit in a language that can guarantee that a given function cannot terminate your program. And that would mean we'd have to at least ignore the result in Rust:

async fn main() -> () {
    let _ = println!("Hello, World!").await;
}

And like, yeah, are you seeing the parallels? It's a handful of small design decisions that make a huge difference here.
And you can absolutely argue that Rust took the less rigorous, less consistent approach for its println!().

I do think, that's fine. Rust doesn't give guarantees for not terminating to begin with and so, if println!() should ever not work, I do think, it's fine to abort mission.
And the decision to not make println!() async doesn't affect the remaining language design. Most production codebases will practically never use println!() anyways and should someone genuinely need an async_println!(), then that can be built.

But yeah, personally, it does excite me to see that the Unison authors thought differently. Even if it's just sheer curiosity what they do with it and whether that added consistency is nice to work with.

Alright as someone who likes Haskell and has dabbled in unison before, I believe I can answer all these questions for you:

• Why is helloWorld there twice?

It is common in languages like haskell and ocaml to first mention the type of a function, so in this case:

• the type of helloWorld is '{IO, Exception} (). That is it's type signature (important for later)
• the implementation of helloWorld is \_ -> println "Hello, World!"

• What's the ' for?
• What are the () for?

Here is where I have to get into the nitty gritty of how unison actually works. Unison has what programming language researchers call an effect system. The type signature of helloWorld indicates that it can perform the IO and Exception types of side effects, and these need to be handled. (in this case, they are handled by the compiler, but other types of side effects can be handled by the programmer themselves)
However, for reasons Unison does not like dealing with eagerly evaluated non-function values with side effects. For this reason, there is '. Essentially, what it does is turn a value into a function that accepts () as it's argument. We could therefore say that the type signature of helloWorld is also () -> {IO, Exception} (). The last () indicates that, next to it's IO and Exception side effects, it also returns () as a value. This is because, in functional programming languages, all functions need to return values (or run infinitely, but that is for another topic)

Now I've been used to functional programming for quite a while now, so things that seem natural to me can be absolutely woozy for anyone not used to this paradigm. So if anything still feels vague to you feel free to comment