Let Binding

A "let binding", in other languages, might be called a "variable declaration". let binds values to names. They can be seen and referenced by code that comes after them.

RE
let greeting = "hello!";
let score = 10;
let newScore = 10 + score;

Block Scope

Bindings can be scoped through {}.

RE
let message = {
  let part1 = "hello";
  let part2 = "world";
  part1 ++ " " ++ part2
};
/* `part1` and `part2` not accessible here! */

The value of the last line of a scope is implicitly returned.

Design Decisions

Reason's if, while and functions all use the same block scoping. The code below works not because of some special "if scope"; but simply because it's the same scope syntax and feature you just saw:

RE
if (displayGreeting) {
  let message = "Enjoying the docs so far?";
  print_endline(message)
};
/* `message` not accessible here! */

Bindings Are Immutable

Reason let bindings are "immutable", aka "cannot change/vary". This helps Reason's type system to deduce and optimize much more than other languages (and in turn, help you more).

Binding Shadowing

The above restriction might sound unpractical at first. How are would you change a value then? Usually, 2 ways:

The first is to realize that many times, what you want isn't to mutate a variable's value. For example, in JavaScript:

JS
var result = 0;
result = calculate(result);
result = calculateSomeMore(result);

What you're really doing is just to name intermediate steps. You didn't need to mutate result at all! You could have just written this:

JS
var result1 = 0;
var result2 = calculate(result1);
var result3 = calculateSomeMore(result2);

In Reason, this obviously works too:

RE
let result1 = 0;
let result2 = calculate(result2);
let result3 = calculateSomeMore(result2);

Anyway, in Reason, we support let binding "shadowing". So you can write this too:

RE
let result = 0;
let result = calculate(result);
let result = calculateSomeMore(result);

As a matter of fact, even this is fine:

RE
let result = "hello";
Js.log(result); // prints "hello"
let result = 1;
Js.log(result); // prints 1

The binding you refer to is whatever's the closest upward. No mutation here! If you need real mutation, e.g. passing a value around, have it modified by many pieces of code, we provide a slightly heavier mutation feature.