How to make sense of "let () ="

In OCaml, how to make sense of a definition like:

let () = print_endline "hello world"

Let-definitions in ocaml should look like let x = e but above () is not a variable. So what happens there?

I think it would make more sense to write:

let _:unit = print_endline "hello world"

The syntax for let bindings is "pattern = expression`. Most often the pattern will be a variable name, a wildcard or a tuple pattern of those, but every kind of pattern is valid (as long as the pattern has the same type as the expression).

The semantics are that the expression will be matched against the pattern and if the match succeeds, the variables bound by the pattern (if any) will be bound during the let's scope. If it fails, there will be an exception.

So for let () = something, you have a pattern that binds no variables and can never fail (since an expression of type unit can never produce a value other than ()). So this is indeed functionally equivalent let _:unit = ..., just a bit more compact.

A let-definition in OCaml can define many values at the same time. For instance, with

let (x,y) = 1, 2 in x + y

we are defining both x and y with the same let.
This works the same as using patterns to bind part of an argument in a function definition

let f (x,_,y) = x + y

(One may note that we can rewrite the let-definition above to use only this second form as

(fun (x,y) -> x + y) (1,2)

)

Moreover, this construction works for all patterns. For instance, we can apply it to pick three variables from nested fields of a record

type x = { x: int; y: int }
type a = { a: x; b:int; c:x }
let { a={ x; _ } ; b; c = {y; _ } } = { a = {x=0;y=1}; b=2; c={x=3;y=4} }

Note that in all illustration above, we were only using product types. The reason here is that exhaustive patterns are bit more exotic for variants, but they are still possible. For instance

type t = A of int | B of int * int * float
let (A x|B(_,x,_)) = A 0

binds x to 0.

Consequently, a definition of the form

let () = print_endline "hello world"

can be seen as a definition where 0 values are bound by the pattern and as the symmetric of

(fun () -> print_endline "hello world")

The syntax for pattern matching matches the syntax for constructors.
Typically a type can have multiple constructors:

 type colour = Red | Blue | Greed

But let's have a unique constructor instead:

 type colour = Red

Then Red is both a constructor and a pattern matching expression for type colour. Here I define a function that constantly returns Red:

let f () = Red

And here I can match it too, given that the match is exhaustive:

let Red = f()

This is not different for the unique constructor of the unit type, which is written () for reasons.

The example above is a bit artificial but if you attach data to the constructor then it is more useful:

type colour = Red of float

Then you can create a shade of red as follows:

let foreground = Red 0.8

And use the pattern matcher in let:

# let darker (Red v) = Red (v *. 0.9)
val darker : colour -> colour = <fun>

For example:

# darker foreground;;
- : colour = Red 0.720000000000000084