Home > Posts > Beginner's Guide to Reason

Beginner's Guide to Reason

  ·   22 min read

Introduction to Reason #

What is Reason? #

Reason is a syntactically delightful, strongly-typed language that compiles to JavaScript. It’s built on top of OCaml, inheriting its powerful type system and functional programming paradigms, but presents a syntax much more familiar to developers coming from languages like JavaScript, C++, or Java. This makes it easier to learn and adopt for a broader range of developers while retaining the performance and reliability benefits of OCaml. Reason’s syntax aims for clarity and consistency, making code easier to read, write, and maintain. It’s particularly well-suited for building complex web applications, but its capabilities extend beyond the browser.

Reason vs. OCaml #

Reason and OCaml share the same underlying compiler and runtime, meaning they offer the same performance and robust type safety. The core difference lies in the syntax. OCaml uses a syntax more traditional to functional programming languages like ML, with significant use of semicolons and parentheses. Reason, on the other hand, boasts a syntax inspired by JavaScript and other popular languages, employing familiar constructs like curly braces {} for blocks and semicolons only where strictly necessary. This syntactic familiarity lowers the barrier to entry for many developers. Think of it as OCaml with a JavaScript-inspired facelift. You can even mix Reason and OCaml code in a single project, leveraging the strengths of both.

Why learn Reason? #

Reason offers several compelling reasons to learn it:

  • Strong Typing: Reason’s powerful type system helps catch errors at compile time, leading to fewer runtime surprises and more robust applications. This results in higher code quality and reduced debugging time.
  • Functional Programming: Reason embraces functional programming principles, promoting immutability, pure functions, and concise code. This makes code easier to understand, test, and reason about.
  • JavaScript Interoperability: Reason compiles to highly optimized JavaScript, allowing seamless integration with existing JavaScript codebases and libraries. This means you can leverage the vast ecosystem of JavaScript while benefiting from Reason’s advantages.
  • Modern Syntax: The familiar syntax reduces the learning curve for developers already proficient in languages like JavaScript, making it easier to adopt and contribute to Reason projects.
  • Performance: Because it compiles to JavaScript, Reason benefits from the performance of modern JavaScript engines. Moreover, the underlying OCaml compiler performs extensive optimizations.
  • Growing Community: While smaller than some other languages, the Reason community is active, supportive, and growing steadily.

Setting up your environment. #

Setting up your Reason development environment typically involves installing the BuckleScript compiler (the compiler that transforms Reason code into JavaScript) and a build system like npm or yarn. The specific steps might vary slightly depending on your operating system (Windows, macOS, Linux), but generally follow these steps:

  1. Node.js and npm (or yarn): Ensure you have Node.js and npm (or yarn, a Node.js package manager) installed on your system. You can download them from the official Node.js website.

  2. Create a new project: Use npm or yarn to create a new project: npm init (or yarn init). This will generate a package.json file.

  3. Install BuckleScript: Install the BuckleScript compiler as a development dependency: npm install --save-dev bs-platform (or yarn add --dev bs-platform).

  4. Create a Reason file: Create a new file (e.g., src/index.re) and start writing your Reason code.

  5. Configure your build process: BuckleScript typically requires some configuration to specify the input and output files, and potentially other build options. This configuration is often done via a bsconfig.json file. Refer to the official BuckleScript documentation for detailed configuration instructions.

These steps provide a basic setup. More advanced setups might involve integrating with a build tool like webpack or Parcel for larger projects. Refer to the official Reason documentation and community resources for more detailed instructions and examples.

Basic Syntax and Data Types #

Variables and Constants #

Reason uses let to declare variables and constants. The key difference lies in mutability: variables can be reassigned, while constants cannot. However, Reason strongly encourages immutability, making constants the preferred choice in most situations.

Constants:

let myConstant = 10;

myConstant is a constant; attempting to reassign it will result in a compiler error.

Variables: (While possible, try to avoid mutable variables where practical)

let mutable myVariable = 5;
myVariable = 15; (* This is allowed *)

myVariable is a mutable variable. Note the use of the mutable keyword, which is generally discouraged unless absolutely necessary for performance reasons or specific algorithms.

Data Types (int, float, string, bool) #

Reason is statically typed, meaning the type of every variable and expression is known at compile time. This leads to increased code reliability and early error detection. Here are some basic data types:

  • int (Integer): Represents whole numbers (e.g., 10, -5, 0).

  • float (Floating-point): Represents numbers with decimal points (e.g., 3.14, -2.5, 0.0).

  • string (String): Represents sequences of characters (e.g., "Hello", "ReasonML"). Strings are delimited by double quotes.

  • bool (Boolean): Represents truth values, either true or false.

let myInt: int = 10;
let myFloat: float = 3.14;
let myString: string = "Reason";
let myBool: bool = true;

Type annotations (like : int above) are optional in many cases; Reason’s type inference system will often deduce the type automatically. However, explicit type annotations improve code readability and maintainability.

Operators #

Reason supports a standard set of operators, similar to those found in other languages:

  • Arithmetic Operators: +, -, *, /, % (modulo).

  • Comparison Operators: =, !=, <, >, <=, >=.

  • Logical Operators: && (AND), || (OR), ! (NOT).

  • Assignment Operator: = (for constants and mutable variables).

let sum = 10 + 5;
let isGreater = 10 > 5;
let result = (10 > 5) && (5 < 10);

Operator precedence follows standard mathematical rules. Parentheses can be used to control the order of evaluation.

Comments #

Reason supports both single-line and multi-line comments:

Single-line comment:

(* This is a single-line comment *)

Multi-line comment:

(**
This is a
multi-line comment.
**)

Comments are crucial for documenting your code, making it easier to understand and maintain. Use comments effectively to explain complex logic or non-obvious code sections.

Working with Functions #

Defining Functions #

Functions in Reason are defined using the let keyword, followed by the function name, its parameters, and its body enclosed in curly braces {}. The return type is often inferred, but can be explicitly specified.

let add = (x: int, y: int) => {
  x + y
};

let greet (name: string) : string = {
  "Hello, " ++ name ++ "!"
};

The add function takes two integer arguments and returns their sum. The greet function takes a string argument and returns a greeting string, explicitly specifying its return type. Note the use of ++ for string concatenation.

Function Arguments and Return Values #

Functions can accept multiple arguments, separated by commas. If a function doesn’t explicitly return a value, it implicitly returns unit, which is Reason’s equivalent of void in other languages. The return value is the last expression evaluated within the function’s body.

let sumThree = (a: int, b: int, c: int) => {
  a + b + c
};

let printMessage (message: string) : unit = {
  Js.log(message);
};

sumThree returns the sum of three integers. printMessage uses Js.log (a JavaScript interop function) to print a message to the console and returns unit because it doesn’t have an explicit return statement.

Anonymous Functions #

Anonymous functions, also known as lambda expressions, are functions without a name. They are often used as arguments to higher-order functions.

let square = (x: int) => x * x;

let numbers = [1, 2, 3, 4, 5];
let squaredNumbers = Array.map(square, numbers);

Here, square is an anonymous function that squares its input. It is passed as an argument to Array.map, which applies the function to each element of the numbers array.

Higher-Order Functions #

Higher-order functions are functions that take other functions as arguments or return functions as their results. Reason’s standard library provides many useful higher-order functions, such as Array.map, Array.filter, and Array.reduce.

let isEven = (x: int) => x mod 2 == 0;
let evenNumbers = Array.filter(isEven, numbers);

let sumArray = Array.reduce((acc, x) => acc + x, 0, numbers);

isEven is a function that checks if a number is even. Array.filter uses it to create a new array containing only the even numbers from numbers. Array.reduce sums all elements in numbers, starting with an initial accumulator value of 0. These examples demonstrate the power and elegance of higher-order functions for concise and expressive code.

Control Flow #

If-else Statements #

Reason’s if-else statements work similarly to those in other languages. They evaluate a condition and execute different blocks of code based on whether the condition is true or false.

let x = 10;

if (x > 5) {
  Js.log("x is greater than 5");
} else {
  Js.log("x is not greater than 5");
};

let message = if (x % 2 == 0) { "Even" } else { "Odd" };
Js.log(message);

The first example demonstrates a standard if-else block. The second shows a concise way to assign a value based on a conditional expression; the if-else expression itself becomes the value assigned to message.

Switch Statements #

Reason’s switch statement provides a way to handle multiple possible values of an expression. It’s particularly useful when dealing with a limited set of known cases. Note that unlike some languages, Reason’s switch requires an exhaustive set of cases (or a default case) to handle all possibilities, which enhances type safety and prevents unexpected behavior.

let day = 3;
switch (day) {
| 1 => Js.log("Monday")
| 2 => Js.log("Tuesday")
| 3 => Js.log("Wednesday")
| 4 => Js.log("Thursday")
| 5 => Js.log("Friday")
| 6 => Js.log("Saturday")
| 7 => Js.log("Sunday")
| _ => Js.log("Invalid day")
};

This switch statement checks the value of day and logs the corresponding day of the week. The _ case acts as a default case, handling any values not explicitly listed (though in this case a better approach would be to enforce a type that only allows values 1-7).

Loops (for, while) #

Reason provides for and while loops for iterative control flow.

for loop: Reason’s for loop is typically used to iterate over arrays or lists.

let numbers = [1, 2, 3, 4, 5];
for i in Array.to_list(numbers) {
  Js.log(i);
};

This example iterates through the numbers array (converted to a list using Array.to_list as for loops in Reason work with lists). Note that you don’t directly access the array index within the loop in this manner. If you need index access, using Array.mapi or similar higher-order functions is generally preferred.

while loop: The while loop continues executing as long as a specified condition is true.

let i = 0;
while (i < 5) {
  Js.log(i);
  i = i + 1;
};

This while loop prints numbers from 0 to 4. Remember to update the loop variable (i) within the loop body to prevent infinite loops. As with for loops, favor using higher-order functions when appropriate for clearer and often more efficient code.

Data Structures #

Reason offers a variety of built-in data structures to organize and manage data efficiently. Understanding these structures is essential for writing effective and maintainable Reason code.

Lists #

Lists are immutable, singly-linked lists. This means that once a list is created, its elements cannot be changed. New lists are created by adding elements to existing ones. They are suitable for situations where frequent modifications are not needed and where immutability is beneficial.

let myList = [1, 2, 3, 4, 5];
let newList = 0 :: myList; (* Add 0 to the beginning *)
let anotherList = myList @ [6, 7]; (* Concatenate lists *)

The :: operator adds an element to the head (beginning) of the list, creating a new list. The @ operator concatenates two lists.

Arrays #

Arrays are mutable, fixed-size collections of elements. They are efficient for accessing elements by their index but less efficient for adding or removing elements compared to lists. Reason’s arrays are more similar to those found in other imperative languages (like C++ or JavaScript).

let myArray = [|1, 2, 3, 4, 5|];
Js.log(myArray[0]);  (* Access the first element *)
myArray[0] = 10;     (* Modify the first element (mutable) *)

Arrays are created using [| ... |] syntax. Elements are accessed using square brackets [] with their index. Note that modifying an array’s element does not create a new array; it changes the original array in place.

Tuples #

Tuples are fixed-size collections of elements of potentially different types. They are used to group related data together.

let myTuple = (1, "hello", 3.14);
let (intVal, strVal, floatVal) = myTuple; (* Destructuring *)
Js.log(intVal);

Tuples are created using parentheses (...). Elements are accessed by their position (starting from 0). Tuple elements can be destructured using pattern matching as shown.

Records #

Records are collections of named fields, each with an associated value. They are useful for representing structured data with meaningful field names.

type person = { name: string, age: int };
let myPerson = { name: "Alice", age: 30 };
Js.log(myPerson.name);

Records are defined using a type declaration. Fields are accessed using the dot operator ..

Variants #

Variants represent values that can take on one of several possible forms (or types). They are a powerful tool for modeling data with different structures or states.

type shape =
  | Circle(float)
  | Rectangle(float, float)
  | Square(float);

let myShape = Circle(5.0);

switch (myShape) {
| Circle(radius) => Js.log("Circle with radius: " ++ string_of_float(radius))
| Rectangle(width, height) => Js.log("Rectangle with width: " ++ string_of_float(width) ++ ", height: " ++ string_of_float(height))
| Square(side) => Js.log("Square with side: " ++ string_of_float(side))
};

Variants are defined using a type declaration with | separating different cases. Each case can have associated data (like the radius of a circle). Variants are often used in conjunction with pattern matching (in switch statements or other pattern matching constructs).

Modules and Namespaces #

Modules in Reason are a way to organize code into logical units, improving code readability, maintainability, and preventing naming conflicts. They provide a form of namespace management.

Creating Modules #

Modules are created by defining a file with the .re extension and using the module keyword. The module’s name is typically the filename (without the extension), though you can explicitly name the module differently if needed.

/* File: myModule.re */
module MyModule = {
  let myFunction = (x: int) => x * 2;
  let myVariable = 10;
};

This creates a module named MyModule containing a function myFunction and a variable myVariable.

Importing Modules #

Modules are imported using the open keyword or explicit path notation.

open: This imports all of the module’s contents into the current scope. While convenient, overuse can lead to naming conflicts.

open MyModule;
let result = myFunction(5); (* Accessing myFunction directly *)

Explicit Path: This provides more control and avoids naming collisions by explicitly referencing the module’s contents.

let result = MyModule.myFunction(5); (* Fully qualified name *)

This explicitly calls myFunction from MyModule. This approach is generally preferred for larger projects.

Namespaces and Module Paths #

Reason’s module system provides namespaces. The module name acts as a namespace, preventing naming collisions between different modules. Module paths are hierarchical. Consider this example:

src/
├── utils/
│   └── stringUtils.re
└── main.re

stringUtils.re might contain:

/* File: src/utils/stringUtils.re */
module StringUtils = {
  let uppercase = (s: string) => Js.String.uppercase(s);
};

main.re can import it with:

open Utils.StringUtils; (* Opens the nested module *)
let upper = uppercase("hello");

(* Or using explicit path: *)
let upper2 = Utils.StringUtils.uppercase("world");

The path Utils.StringUtils uniquely identifies the uppercase function within the project’s namespace. This hierarchical structure allows for the organization of code into logical units, avoiding naming conflicts even with many modules involved. Long, nested paths can be mitigated by using open judiciously for commonly used sub-modules.

Working with React (If applicable) #

ReasonReact is a ReasonML binding for React, allowing you to build user interfaces with the power of Reason and the flexibility of React.

Setting up a ReasonReact project #

Setting up a ReasonReact project typically involves using a project scaffolding tool like create-reason-app or manually configuring a project with bs-platform and necessary dependencies. create-reason-app is the recommended approach for beginners.

Using create-reason-app:

  1. Install Node.js and npm: Ensure Node.js and npm (or yarn) are installed on your system.

  2. Install create-reason-app globally: Run npm install -g create-reason-app (or yarn global add create-reason-app).

  3. Create a new project: Use the command create-reason-app my-reason-react-app. Replace my-reason-react-app with your desired project name.

  4. Navigate to the project directory: cd my-reason-react-app.

  5. Start the development server: npm start (or yarn start).

This will create a basic ReasonReact application and start a development server.

Manual Setup (Advanced): This involves creating a package.json, installing bs-platform and reason-react, configuring bsconfig.json, and setting up your build process. This approach is more complex and generally only recommended for experienced developers who need more control over their project configuration. Refer to the official ReasonReact documentation for detailed instructions on manual setup.

Basic Components #

ReasonReact components are defined using the ReasonReact.component function. They take a component definition as an argument, which describes the component’s rendering logic and handling of events.

open ReasonReact;

let component = ReasonReact.component("MyComponent");

let make = (~props: { message: string }) => {
  {/* Render JSX within ReasonReact */ }
  {
    ReactDOMRe.renderToElementWithId(
      ReasonReact.element(component, ~props, []),
      "root",
    );
  }
};

let (MyComponent, _) = component;

ReactDOMRe.renderToElementWithId(ReasonReact.element(MyComponent, ~message: "Hello from ReasonReact!", []), "root");

This creates a component named “MyComponent” that takes a message prop and renders it to the DOM. Note the use of ReasonReact’s JSX-like syntax within the component’s render function.

Props and State #

Props: Props are immutable values passed from a parent component to a child component. They are similar to React’s props.

State: State is mutable data that is managed within a component. Changes to the state trigger re-renders of the component. ReasonReact manages state using the state argument in make and updating it using ReasonReact.update.

open ReasonReact;

let component = ReasonReact.component("Counter");

let make = (~props: unit, ~state: (int, ReasonReact.action)) => {
  {
    state: (state, (fun () => update(state, (fun prevCount => prevCount + 1)))),
    render: (state, ~action: action)=> {
      <div>
        <p>Count: {state[0]}</p>
        <button onClick={state[1]}>Increment</button>
      </div>
    }
  }
};

let (Counter, _) = component;

ReactDOMRe.renderToElementWithId(ReasonReact.element(Counter, ~props:(),~state:(0,(fun () => update(state, (fun prevCount => prevCount + 1))))), "root");

This Counter component manages an internal count using state, which can be incremented by clicking a button.

Component Lifecycle #

ReasonReact provides lifecycle methods (though with slightly different naming conventions than React) to manage various aspects of a component’s behavior:

  • make: This function is responsible for initializing the component’s state and specifying its rendering logic. It’s analogous to React’s constructor, render, and certain lifecycle methods.

  • update: This function handles state updates triggered by events or other actions.

  • didMount: Called after the component is mounted to the DOM.

  • willUnmount: Called just before the component is unmounted from the DOM.

Implementing these functions allow you to manage component state and respond to lifecycle events in a structured and predictable manner within a ReasonReact application. Consult the ReasonReact documentation for detailed examples and explanations.

Error Handling #

Reason offers several ways to handle errors gracefully, preventing unexpected crashes and improving code robustness. The primary mechanisms are exceptions, the Result type, and the Option type.

Exceptions #

Exceptions are used to signal exceptional situations that disrupt the normal flow of execution. While exceptions exist, Reason’s strong typing and functional paradigm encourage alternative approaches like the Result and Option types for more predictable error handling.

exception MyError;

let myFunction = () => {
  try {
    /* Code that might raise an exception */
    raise(MyError);
  } {
  | MyError => Js.log("MyError caught!")
  | _ => Js.log("Other error caught!")
  }
};

myFunction();

This code defines a custom exception MyError. The try...{|} block handles potential exceptions. The | MyError => ... clause handles specifically the MyError exception while the | _ => ... handles any other exception types. While functional approaches are preferred, exceptions are useful for truly exceptional situations outside the normal control flow.

Result type #

The Result type represents an operation that can either succeed with a value or fail with an error. It’s a powerful tool for handling expected errors in a structured way. A Result is either Ok(value) (success) or Error(error).

type result<'a, 'b> = Ok('a) | Error('b);

let myFunction = (x: int) : result<int, string> => {
  if (x > 0) {
    Ok(x * 2)
  } else {
    Error("Input must be positive")
  }
};

let result = myFunction(-5);
switch (result) {
| Ok(value) => Js.log("Success: " ++ string_of_int(value))
| Error(message) => Js.log("Error: " ++ message)
};

This example defines a function myFunction that returns a Result. If x is positive, it returns Ok with the doubled value; otherwise, it returns Error with an error message. The switch statement handles the two possible outcomes. Pattern matching is a key component to working with Result values.

Option type #

The Option type represents a value that may or may not be present. It’s useful for handling situations where a value might be missing or undefined. An Option is either Some(value) (value present) or None (value absent).

let myFunction = (x: int) : option<int> => {
  if (x > 0) {
    Some(x)
  } else {
    None
  }
};

let optionValue = myFunction(5);

switch (optionValue) {
| Some(value) => Js.log("Value: " ++ string_of_int(value))
| None => Js.log("Value is None")
};

This shows a function myFunction that returns an Option. It returns Some(x) if x is positive and None otherwise. The switch statement handles both possibilities. Pattern matching on Option is also critical to its usage. Using Option avoids common errors like trying to access a potentially null or undefined value. It enforces handling the possibility of missing data explicitly.

Advanced Concepts (Optional) #

This section covers more advanced concepts in Reason that are beneficial for building more complex and robust applications.

Type Inference #

Reason possesses a powerful type inference system. This means the compiler can often deduce the types of variables and expressions without explicit type annotations. While not strictly required in many cases, type annotations are highly recommended for improved code readability and maintainability, especially in larger projects. Type inference helps reduce boilerplate code and allows developers to focus on the logic. However, understanding how type inference works can help you debug type-related issues more efficiently.

let x = 10;  (* Type inferred as int *)
let y = "hello"; (* Type inferred as string *)
let z = x + 5; (* Type inferred as int *)

In this example, the compiler infers the types of x, y, and z based on their usage.

Algebraic Data Types (ADTs) #

Algebraic Data Types (ADTs) allow you to define types that can represent one of several possible variants. This is similar to the concept of variants described earlier but extends to more complex data structures. ADTs are powerful for modeling complex domains and improving code clarity.

type shape =
  | Circle of { radius: float }
  | Rectangle of { width: float; height: float }
  | Square of { side: float };

let area = (shape) => {
  switch (shape) {
  | Circle({radius}) => 3.14 *. radius *. radius
  | Rectangle({width, height}) => width *. height
  | Square({side}) => side *. side
  }
};

This defines an ADT shape that can be a Circle, Rectangle, or Square. The area function uses pattern matching to calculate the area of each shape variant.

Pattern Matching #

Pattern matching is a powerful technique for extracting values from data structures like tuples, records, variants, and ADTs. It provides a concise and expressive way to handle different cases in a switch-like manner. Pattern matching improves code readability and reduces the need for verbose if-else chains.

let myTuple = (1, "hello", true);
let (a, b, c) = myTuple;  (* Pattern matching in destructuring *)

switch (myTuple) {
| (1, str, true) => Js.log("Matched!")
| _ => Js.log("Not matched")
};

This example shows pattern matching in tuple destructuring and in a switch statement.

Functors #

A functor is a type constructor that can be mapped over. This enables applying a function to the underlying type within the functor without breaking the structure of the functor itself. This concept is closely related to higher-order functions and is a building block for more advanced functional programming concepts.

Monads #

Monads are a more advanced functional programming concept. In essence, they’re a type constructor with specific methods (bind/>>= and return/>>) for sequencing computations in a controlled manner. Common examples in Reason include the Result and Option types, which we’ve already discussed, showing how they naturally fit into a monadic pattern. Understanding monads is beneficial for working with asynchronous operations or handling side effects in a functional way. They provide a way to chain operations that may fail or produce multiple results.

These advanced concepts provide powerful tools for creating sophisticated and well-structured Reason applications. They are not strictly required for beginner-level development, but mastering them will significantly enhance your abilities in functional programming and Reason development.

Next Steps and Resources #

This section provides pointers to help you continue your Reason journey and stay up-to-date with the latest developments.

Community and Support #

The Reason community is active and supportive. Several avenues exist for getting help and interacting with other developers:

  • Reason Discord Server: The official Reason Discord server is a great place to ask questions, share your work, and connect with other Reason developers. You’ll find many experienced users willing to assist beginners.

  • ReasonML Forum: The ReasonML forum is another valuable resource for finding answers to your questions and participating in discussions.

  • Stack Overflow: Stack Overflow is a general-purpose Q&A site, and you’ll find many Reason-related questions and answers there. Remember to search for existing answers before asking a new question.

  • GitHub: The ReasonML GitHub organization hosts numerous repositories, including the Reason compiler, ReasonReact, and many community-contributed libraries. It is a good place to report bugs, contribute code, or review existing projects.

Don’t hesitate to reach out to the community – most Reason developers are eager to help newcomers.

Further Learning Resources #

Beyond this Beginner’s Guide, numerous resources are available to deepen your understanding of Reason:

  • Official Reason Website: The official Reason website (https://reasonml.github.io/) provides comprehensive documentation, tutorials, and examples.

  • ReasonML Tutorial: The official tutorial provides a structured path for learning Reason, covering various aspects of the language and its ecosystem.

  • ReasonReact Documentation: If you’re interested in building web applications, the ReasonReact documentation is a valuable resource.

  • Online Courses: Several online platforms offer Reason and functional programming courses that might suit your learning style.

Reason Projects to Explore #

Exploring existing Reason projects is a great way to learn practical techniques and see how Reason is used in real-world applications. Here are a few suggestions:

  • ReasonReact Examples: The ReasonReact repository includes several example applications demonstrating various aspects of building React components with Reason.

  • Community-Contributed Libraries: Browse the Reason package repository (if applicable) to discover libraries and modules contributed by the community. These provide insights into best practices and common design patterns.

  • Open-Source Reason Projects: Search GitHub for open-source projects written in Reason. Contributing to these projects is an excellent way to learn and gain experience. Look for projects that align with your interests or skill level.

By actively participating in the community, exploring existing resources, and engaging with open-source projects, you can continually expand your Reason skills and build increasingly sophisticated applications.

←
Beginner's Guide to Common Lisp
Beginner's Guide to Nim
→
back to top