Home

ReasonML Hello World

tl;dr

Reason comes by default with BuckleScript.

npm install -g bs-platform bsb -init my-new-project -theme basic-reason cd my-new-project yarn build # or npm run build, for npm node src/Demo.bs.js

Let Binding

JavaScriptReason
const x = 5;let x = 5;
var x = y;No equivalent (thankfully)
let x = 5; x = x + 1;let x = ref(5); x := x^ + 1;

String & Char

JavaScriptReason
"Hello world!"Same
'Hello world!'Strings must use "
Characters are strings'a'
"hello " + "world""hello " ++ "world"

Boolean

JavaScriptReason
true, falseSame
!trueSame
`
a === b, a !== bSame
No deep equality (recursive compare)a == b, a != b
a == bNo equality with implicit casting (thankfully)

Number

JavaScriptReason
3Same
3.1415Same
3 + 4Same
3.0 + 4.53.0 +. 4.5
5 % 35 mod 3

* JS has no distinction between integer and float.

Object/Record

JavaScriptReason
no static typestype point = {x: int, mutable y: int}
{x: 30, y: 20}Same
point.xSame
point.y = 30;Same
{...point, x: 30}Same

* This is the Reason spiritual equivalent; it doesn't mean it compiles to JS' object! To compile to the latter, see here.

Array

JavaScriptReason
[1, 2, 3]`[
myArray[1] = 10Same
[1, "Bob", true] *(1, "Bob", true)
No immutable list[1, 2, 3]

* We can simulate tuples in JavaScript with arrays, because JavaScript arrays can contain multiple types of elements.

Null

JavaScriptReason
null, undefinedNone *

* Again, only a spiritual equivalent; Reason doesn't have nulls, nor null bugs! But it does have an option type for when you actually need nullability.

Function

JavaScriptReason
arg => retVal(arg) => retVal
function named(arg) {...}let named = (arg) => ...
const f = function(arg) {...}let f = (arg) => ...
add(4, add(5, 6))Same

Blocks

JavaScript:

const myFun = (x, y) => { const doubleX = x + x; const doubleY = y + y; return doubleX + doubleY; };

Reason:

let myFun = (x, y) => { let doubleX = x + x; let doubleY = y + y; doubleX + doubleY };

Currying

JavaScriptReason
let add = a => b => a + blet add = (a, b) => a + b

Both JavaScript and Reason support currying, but Reason currying is built-in and optimized to avoid intermediate function allocation & calls, whenever possible.

If-else

JavaScriptReason
if (a) {b} else {c}Same *
a ? b : cSame
switchswitch but super-powered!

* Reason conditionals are always expressions!

Destructuring

JavaScriptReason
const {a, b} = datalet {a, b} = data
const [a, b] = data`let [
const {a: aa, b: bb} = datalet {a: aa, b: bb} = data

* Gives good compiler warning that data might not be of length 2. Switch to pattern-matching instead.

Loop

JavaScriptReason
for (let i = 0; i <= 10; i++) {...}for (i in 0 to 10) {...}
for (let i = 10; i >= 0; i--) {...}for (i in 10 downto 0) {...}
while (true) {...}Same

JSX

JavaScriptReason
<Foo bar=1 baz="hi" onClick={bla} />Same
<Foo bar=bar /><Foo bar /> *
<input checked /><input checked=true />
No children spread<Foo>...children</Foo>

* Argument punning!

Exception

JavaScriptReason
throw new SomeError(...)raise(SomeError(...))
try {a} catch (Err) {...} finally {...}`try (a) {

* No finally.

Blocks

In Reason, "sequence expressions" are created with {} and evaluate to their last statement. In JavaScript, this can be simulated via an immediately-invoked function expression (since function bodies have their own local scope).

JavaScript:

const myFun = (x, y) => { const doubleX = x + x; const doubleY = y + y; return doubleX + doubleY; };

Reason:

let myFun = (x, y) => { let doubleX = x + x; let doubleY = y + y; doubleX + doubleY };

Comments

JavaScriptReason
/* Comment */Same
// Line commentComing soon

Repository

https://github.com/okeeffed/developer-notes-nextjs/content/reasonml/reason-hello-world

Sections


Related