Translate

Обзор

Это обзор большинства языковых особенностей в Reason. Он не объясняет их детально, но может использоваться как быстрая справка. Пожалуйста, ознакомьтесь с инструкциями слева для получения дополнительной информации о каждой особенности.

Присваивание

Подробности: Присваивание

Тип значения	Пример
Строковое значение	let hi = "Привет, мир";
Целочисленное значение	let count = 42;
Аннотация типа при присваивании	let count: int = 42;

• Примечание: Присваивания являются немутабельными и не могут быть изменены после создания.

Встроенные типы

Details: Primitives

Тип	Пример
Int	let x: int = 10;
Float	let x: float = 10.0;
Boolean	let x: bool = false;
String	let x: string = "ten";
Char	let x: char = 'c';
Unit	let x: unit = ();
Option	let x: option(int) = Some(10);
Tuple	let x: (int, string) = (10, "ten");
List	let x: list(int) = [1, 2, 3];
Array	let x: array(int) = [|1, 2, 3|];
Functions	let x: (int, int) => int = (a, b) => a + b;

Строки

Details: Strings

Тип значения	Пример
Строка	"Привет"
Конкатенация строк	"Привет, " ++ "мир"
Символ	'x'
Символ по индексу	let x = "Привет"; x.[2];

• Строковые функции: модуль String

Числа

• Details: Integer
• Details: Float

Тип значения	Пример
Целое число	23, -23
Целочисленные операции	23 + 1 - 7 * 2 / 5
Целочисленный остаток от деления	13 mod 2
Числа с плавающей запятой	23.0, -23.0
Операции над Float	23.0 +. 1.0 -. 7.0 *. 2.0 /. 5.0
Возведение Float в степень	2.0 ** 3.0

Booleans and Logical Operators

Details: Boolean

Тип	Пример
Булевы значения	true, false
Сравнение	>, <, >=, <=
Логические операторы	!, &&, &#124;&#124;
Ссылочное равенство	===, !==
Структурное равенство	==, !=

If-Else Expressions

Тип	Пример
If-Else expressions	if (condition) { a; } else { b; }
Ternary expressions	condition ? a : b;

• Note: These are expressions and can be assigned to a variable: let x = if (condition) { a; } else { b; };

Functions

Details: Functions

Описание	Пример
Function definition	let divide = (a, b) => a / b;
Function calls	divide(6, 2); // 3
Named arguments	let divide = (~a, ~b) => a / b;
Calling named arguments	divide(~a=6, ~b=2); // 3
Named argument punning	divide(~a, ~b);
Recursive functions	let rec infinite = () => infinite();

Advanced Functions

Тип	Пример
Partial application	let divideTen = divide(10); divideTen(5); // 2
Partially applying out of order	let half = divide(_, 2); half(10); // 5
Optional arguments	let print = (~prefix=?, text) => {...};
Optional arguments with default	let divide = (~a=100, ~b) => a / b;
Function chaining (pipe)	32 |> half |> half; // 8

Function Types

Тип	Пример
Inline typing	let divide = (a: int, b: int): int => a / b;
Standalone type	type intFn = (int, int) => int;
Using standalone type	let divide: intFn = (a, b) => a / b;
Typing optional arguments	let print = (~prefix: option(string)=?, text) => {...};

Implicit Return

There is no return keyword in Reason. The last expression in a block or function definition is the returned value.

let twentyThree = () => {
  let x = 10;
  let x = x + 10;
  /* x + 3 is the implicit return of the function. */
  x + 3;
};

Basic Structures

Details: Basic Structures

Описание	Пример
List (Immutable)	[1, 2, 3]
List add to front	[a1, a2, ...theRest]
List concat	[a1, a2] @ theRest
Array (Mutable)	[|1, 2, 3|]
Array access	let arr = [|1, 2, 3|]; arr[1];
Tuples	(1, "hello")

• List Functions: module List
• Array Functions: module Array

Maps and Sets

There are several different ways to interact with Maps and Sets depending on the specific environment being used. In standard Reason code there are Map and Set modules:

• module Map.Make
• module Set.Make

When using BuckleScript belt exposes these modules:

• module Belt.Map
• module Belt.Set

There are also other libraries that will provide their own implementation of these data structures. Check the style guide of the project you are working in to determine which module to use.

Type Annotations

Any expression or argument may include a "type annotation". In most cases, type annotations are not necessary and the compiler will infer the types automatically. You may include type annotations to verify your own understanding against what the compiler infers.

Описание	Пример
Expression type annotation	let x = (expression: int)
Annotation on let binding	let x: int = expression;
Argument/return value annotation	let addOne = (a: int): int => a + 1;

Type Parameters

Types can be made generic with type parameters.

Описание	Пример
Type parameters	type pair('a, 'b) = ('a, 'b);
Annotation with parameters	let x: pair(int, string) = (10, "ten");
String list	let x: list(string) = ["Hello", "World"];

Records

Details: Records

Feature	Example
Record definition	type t = {foo: int, bar: string};
Record creation	let x = {foo: 10, bar: "hello"};
Record access	x.foo;
Record spread	let y = {...x, bar: "world"};
Destructuring	let {foo, bar} = x;
Mutable record fields	type t = {mutable baz: int}; let z = {baz: 10};
Mutable record updates	z.baz = 23;
With type parameters	type t('a) = {foo: 'a, bar: string};

• Note: Record types are nominal. This means that two different record definitions (type x = {...};) with the exact same fields are not compatible. They cannot be used interchangeably and cannot be spread into each other.

Variants

Details: Variants

Variant types model values that may assume one of many known variations. This feature is similar to "enums" in other languages, but each variant form may optionally specify data that is carried along with it.

Feature	Example
Variant definition	type t = | Foo | Bar;
Variants with args	type t = | Foo(string) | Bar(int);
With type parameters	type t('a) = | One('a) | Two('a, 'a);
Using a variant	let x = Two("Hello", "World");

Options

Details: Options

Options are a built-in variant that represent the presence or absence of a value. It is similar to the concept of "nullable" values in other languages. Options are used often.

Feature	Example
Definition (already defined)	type option('a) = | None | Some('a);
Value that is present	let x = Some("Hello World");
Value that is absent	let y = None;

Pattern Matching

Pattern matching is a very powerful feature in Reason. It matches against variants and ensures all cases are covered. Start matching using the switch keyword:

switch (foo) {
| Some(value) => doSomething(value)
| None => error()
}

Feature	Example
Basic case	| Some(value) => doSomething(value)
When conditions	| Some(value) when value > 10 => doSomething(value)
Catch-all case	| _ => doSomething()
Matching lists	| [a, b, ...rest] => doSomething(rest)
Matching records	| {foo: value} => doSomething(value)
Matching literals	| "Hello" => handleHello()

Unit

The special "unit" value (written ()) represents something that never has any meaningful value (this is distinct from options which may have a value). Functions usually indicate that they perform a side effect by returning a unit value.

Feature	Example
Creating a unit	let x = ();
Passing to a function	fn(a, b, ());
Unit as only argument	let fn = () => 1; fn();

Refs

Details: Mutable Bindings

Refs allow mutable "variables" in your program. They are a thin wrapper around a record with a mutable field called contents.

Feature	Example
Type (already defined)	type ref('a) = {mutable contents: 'a};
Ref creation	let x = ref(10); or let x = {contents: 10};
Ref access	x^; or x.contents;
Ref update	x := 20; or x.contents = 20;

Loops

Details: Loops

Loops are discouraged in most cases. Instead functional programming patterns like map, filter, or reduce can usually be used in their place.

Feature	Example
While	while (condition) {...}
For (incrementing)	for (i in 0 to 9) {...} (inclusive)
For (decrementing)	for (i in 9 downto 0) {...} (inclusive)

• Note: There is no break or early returns in Reason. Use a ref containing a bool for break-like behavior: let break = ref(false); while (!break^ && condition) {...};

Modules

Details: Modules

Modules are a way to group types and values. Each Reason file implicitly creates a module of the same name. Each type definition and let binding in a module automatically becomes a "member" of that module which can be accessed by other modules. Modules can also be nested using the module keyword.

Feature	Example
Module creation	module Foo = { let bar = 10; };
Module member access	Foo.bar;
Module types	module type Foo = { let bar: int; };

Functors

Functors are like functions that create modules. This is an advanced topic that can be very powerful. Here is a basic example:

module type Stringable = {
  type t;
  let toString: (t) => string;
};

module Printer = (Item: Stringable) => {
  let print = (t: Item.t) => {
    print_endline(Item.toString(t));
  };

  let printList = (list: list(Item.t)) => {
    list
    |> List.map(Item.toString)
    |> String.concat(", ")
    |> print_endline;
  };
};

module IntPrinter = Printer({
  type t = int;
  let toString = string_of_int;
});

IntPrinter.print(10); // 10
IntPrinter.printList([1, 2, 3]); // 1, 2, 3

Comments

Feature	Example
Multiline Comment	/* Comment here */
Single line Comment	// Comment here