This course foremost will teach you about the syntax and semantics of the programming language Reason or also referred to as ReasonML. In addition, the course touches on best practices recommended by the official documentation. Each lesson is focusing on a specific feature, concept or best practice and can be watched independently. Still, the whole course is carefully crafted, and each lesson builds up on the previous ones.

The goal of this course is to explain syntax and semantics of the programming language Reason.

Each lesson is focusing on a specific feature or concept and can be watched independently. Still the whole course is carefully crafted and each lesson builds up on the previous ones.

In this intro I also talk about the three reasons why I care about the language.

I hope the course is helpful to you and I'm looking forward to hear what you build with Reason.

Course Overview: Get started with Reason

In this lesson we setup the ReasonML repl **rtop**, evaluate our first statement and explore rtop's most important features like reverse search through multiple lessons. We finish up with a demonstration of Reason's formatting tool **refmt** in the editor Atom.

Setting up reason-cli, first Steps with rtop and Editor Support in Reason

In this lesson we explore ReasonML's language basic datatypes like `integer`, `float`, `boolean`, `string`, `char`, `unit` and `list`. Further you will get familiar with the addition operator, several relational operators as well as structural equality.

Basic Datatypes and Operators in Reason

Let bindings allow to bind values to names similar to variable declaration in other languages. There are subtle differences tough in every language and we are going to explore the semantics of ReasonML's let bindings. Further we see how type inference works and it's implications. Last but not least we discover type alias.

Let bindings, Type Inference and Type Aliases in Reason

Reason has lexical scope. In this lesson we explore what this means for the visibility of bindings using local block scopes.

Scope in Reason

First we are going to investigate the if expression and compare it to JavaScript's if statement. If being an expression has multiple implications on how to use it. In the second part we are introducing the ReasonML's switch expression in it's simplest form using structural equality as well as the fall-through case.

if-else and Switch Expressions in Reason

Records are like JavaScript objects but are

* immutable by default
* fixed in field names and types

We walk through how to create, access, update and destructure records. In certain niche situations we don't know the structure of our data ahead. In such cases using ReasonML objects works great.

Records and Objects in Reason

Variants are known as tagged unions in Computer Science. They allow us to express multiple options that are exclusive, as a data structure. A concept that isn't available in too many programming languages and yet such a powerful concept.

We explore how to create variants and constructors in ReasonML and briefly touch on how to pattern match them to extract data.

Variants and Pattern Matching Variants using switch in Reason

The ability to express multiple options that are exclusive as a data structure is a powerful concept. To leverage it's full power it's requires some rethinking on how to model our data.

We are going use a simple UI example to rethink how to approach representing our state.

This lesson was highly inspired by Yaron Minky's advice to "make illegal states unrepresentable" in his talk [Effective ML](https://vimeo.com/14313378) as well as Richard Feldman's talk [Making impossible states impossible](https://www.youtube.com/watch?v=IcgmSRJHu_8&t=354s) with Elm.

Elminate Illegal States in Reason with Variants

ReasonML doesn't null. Still sometimes we want to refer to something and don't know ahead if a corresponding value will be available.
Reason therefor offers the Variant option shipping with the standard library.

Using Reason's Type option

In this lesson we walk through how to declare functions in ReasonML. Declaring and using functions is straightforward. Still there are a handful great features not available in a lot of other languages like labeled arguments or auto currying. Both are explained in this lesson.

Declare Functions in Reason

Concise and readable code is an important aspect of good quality and maintainability. The reverse-application operator aka. pipe operator allows us to chain functions together without the hassle of creating intermediate let bindings or complicated nesting.

Chain Functions using the pipe/reverse-application Operator in Reason

Function recursion requires the let binding to be accessible inside it's own local scope. Using the `rec` keyword in ReasonML we can enable this visibility to declare recursion functions.

Recursive Functions in Reason

ReasonML ships with a couple more useful data structures to store multiple elements. Tuple is one of them. It allows us to store a fixed number of values of any kind of type. While lists are homogeneous and immutable. Arrays are mutable.

In this lesson we explore multiples ways on how to create, access and update each of these data structures.

Tuples, Lists and Arrays in Reason

In this lesson we explore what structural equality as well as referential equality means in ReasonML. We walk through a couple examples and end with a handful of ideas on what to use when.

Reference Equality vs Structural (deep) Equality

Pattern matching is probably one of the best features of the language. It comes down to two points:

- check for a certain structure of a value
- extract parts of that value

Since it's such an integral part of the language it comes with a lot of useful tricks like piping multiple patterns into one case. In this lesson we will explore all of them.

Pattern Matching using switch in Reason

In this lesson we will explore a bit more advances type system feature: type parameters. They are similar to generics in other languages. We create our own types using type parameters to demonstrate why they are useful.

Type Parameters in Reason

Immutability comes with lots of benefits. Working with a programming language with first class immutable data structures is a blaze. Nevertheless sometimes it can be useful to have a binding that's mutable. Using references we can achieve this in ReasonML.

Mutable let bindings in Reason

While it's not recommend to make extensive use of exceptions in ReasonML, it's still worth introducing them. In this lesson we walk through how to create, raise and catch them.

Exceptions in Reason

In functional programming languages `map`, `filter` and `reduce` are often preferred over imperative loops. As stated in the official Reason docs the language creates don't have a preference on whether you should use a loop over these function.

In Reason we have `for` as well as `while` available.

Imperative Loops (for & while) in Reason

Modules allow us to encapsulate business logic like let bindings or types into logical entities. In ReasonML every file is a module. Names have to be unique though per project. This is quite opinionated compared to other languages. Sub-modules also can be created using the `module` keyword. In addition to that ReasonML supports interface files that not only describe let bindings, functions and their types, but also enforce visibility of those. In this lesson we explore all of these features step by step without getting overwhelmed.

Modules in Reason

At it's core BuckelScript is a backend for the OCaml compiler to emits JavaScript. Luckily it support not only OCaml, but also ReasonML syntax out of the box. In addition BuckleScript comes with a whole toolchain to make our lifes easier.

In this lesson we will setup the tooling to create and build a new project. We explore it's structure and add a new module.

Get Started with Reason

Instructor

Course content (22 lessons)

Instructor