A spread is three dots in a row: .... Spreads have many different uses in ReScript depending on in which context it is used.

Record definitions

Available in v10+

Spreads can be used to copy fields from one record definition into another.

RES
type a = {
  id: string,
  name: string,
}

type b = {
  age: int
}

type c = {
  ...a,
  ...b,
  active: bool
}

Read more about record type spreads here.

Record immutable update

Spreads can be used for immutable updates of records:

RES
let meNextYear = {...me, age: me.age + 1}

Read more about record immutable updates here.

Variant definitions

Available in v11+

Spreads can be used to copy constructors from one variant definition to another.

RES
type a = One | Two | Three
type b = | ...a | Four | Five
// b is now One | Two | Three | Four | Five

Read more about variant type spreads here.

Variant pattern matching

Available in v12+

You can refine the type of a variant by spreading compatible a variant when pattern matching:

RES
type pets = Cat | Dog
type fish = Cod | Salmon
type animals = | ...pets | ...fish

let isPet = (animal: animals) => {
  switch animal {
  | ...dog => Console.log("A dog!")
  | _ => Console.log("Not a dog...")
  }
}

Polymorphic variant pattern matching

You can refine compatible polymorphic variants when pattern matching:

RES
type red = [#Ruby | #Redwood | #Rust]
type blue = [#Sapphire | #Neon | #Navy]

// Contains all constructors of red and blue.
// Also adds #Papayawhip
type color = [red | blue | #Papayawhip]

let myColor: color = #Ruby

switch myColor {
| #...blue => Console.log("This blue-ish")
| #...red => Console.log("This red-ish")
| other => Console.log2("Other color than red and blue: ", other)
}

List immutable update

Spreads can be used for immutable updates of lists:

RES
let prepended = list{1, ...someOtherList}

// You can spread several lists, but it's O(n) so avoid it if possible
let multiple = list{1, ...prepended, ...anotherList}

Read more about immutable list updates here.

List pattern matching

Spreads can be used when pattern matching on lists:

RES
let rec printStudents = (students) => {
  switch students {
  | list{} => () // done
  | list{student} => Console.log("Last student: " ++ student)
  | list{student1, ...otherStudents} =>
    Console.log(student1)
    printStudents(otherStudents)
  }
}
printStudents(list{"Jane", "Harvey", "Patrick"})

Read more about pattern matching on lists.

Array immutable update

Available in v11+

You can use spreads to add the contents of one array to another, just like in JavaScript:

RES
let firstArray = [1, 2, 3]
let secondArray = [...firstArray, 4, 5]

Partial application of functions

Available in v11+ (uncurried mode)

You can partially apply a function using the spread syntax. Partially applying a function will return a new function taking only the arguments that wasn't applied partially.

RES
let add = (a, b) => a + b
let addFive = add(5, ...)

Read more about partial application of functions.

Syntax Lookup