#Array Package Documentation

This package provides array manipulation utilities for MoonBit, including fixed-size arrays (FixedArray), dynamic arrays (Array), and array views (ArrayView/View).

#Creating Arrays

There are several ways to create arrays in MoonBit:

///|
test "array creation" {
  // Using array literal
  let arr1 = [1, 2, 3]
  debug_inspect(arr1, content="[1, 2, 3]")

  // Creating with indices
  let arr2 = Array::makei(3, i => i * 2)
  debug_inspect(arr2, content="[0, 2, 4]")

  // Creating from iterator
  let arr3 = Array::from_iter("hello".iter())
  debug_inspect(arr3, content="['h', 'e', 'l', 'l', 'o']")
}

#Array Operations

Common array operations include mapping, filtering, and folding:

///|
test "array operations" {
  let nums = [1, 2, 3, 4, 5]

  // Filtering out odd numbers and negating the remaining
  let neg_evens = nums.filter_map(x => if x % 2 == 0 { Some(-x) } else { None })
  debug_inspect(neg_evens, content="[-2, -4]")

  // Summing array
  let sum = nums.fold(init=0, (acc, x) => acc + x)
  inspect(sum, content="15")

  // Finding last element
  let last = nums.last()
  debug_inspect(last, content="Some(5)")
}

#Sorting

The package provides various sorting utilities:

///|
test "sorting" {
  let arr = [3, 1, 4, 1, 5, 9, 2, 6]

  // Basic sorting - creates new sorted array
  let sorted1 = arr.copy()
  sorted1.sort()
  debug_inspect(sorted1, content="[1, 1, 2, 3, 4, 5, 6, 9]")

  // Custom comparison
  let strs = ["aa", "b", "ccc"]
  let sorted2 = strs.copy()
  sorted2.sort_by((a, b) => a.length().compare(b.length()))
  debug_inspect(
    sorted2,
    content=(
      #|["b", "aa", "ccc"]
    ),
  )

  // Sort by key
  let pairs = [(2, "b"), (1, "a"), (3, "c")]
  let sorted3 = pairs.copy()
  sorted3.sort_by_key(p => p.0)
  debug_inspect(
    sorted3,
    content=(
      #|[(1, "a"), (2, "b"), (3, "c")]
    ),
  )
}

#Array Views

Array views provide a lightweight way to work with array slices. The arr[start:end] syntax clamps each bound to [0, arr.length()]; negative bounds clamp to zero and inverted ranges produce empty views. Omitting either bound uses the corresponding end of the array. These rules also apply to FixedArray, ReadOnlyArray, ArrayView, and MutArrayView, with offsets relative to the current view. Use arr.exact_view(start~, end~) to require valid bounds, or arr.get_view(start~, end~) to return None for invalid bounds on types that provide it. The old view and sub names are deprecated in favor of exact_view.

///|
test "array views" {
  let arr = [1, 2, 3, 4, 5]
  let view = arr[1:4]
  debug_inspect(
    view,
    content=(
      #|<ArrayView: [2, 3, 4]>
    ),
  )

  // Map view to new array
  let doubled = view.map(x => x * 2)
  debug_inspect(doubled, content="[4, 6, 8]")
}

#Fixed Arrays

Fixed arrays have a fixed length, but their elements are mutable. Use ReadOnlyArray when element assignment should be unavailable:

///|
test "fixed arrays" {
  let fixed : FixedArray[_] = [1, 2, 3]

  // Concatenation creates new array
  let combined = fixed + [4, 5]
  debug_inspect(
    combined,
    content=(
      #|<FixedArray: [1, 2, 3, 4, 5]>
    ),
  )

  // Check for containment
  let has_two = fixed.contains(2)
  inspect(has_two, content="true")

  // Check if array starts/ends with sequence
  let starts = fixed.starts_with([1, 2])
  inspect(starts, content="true")
  let ends = fixed.ends_with([2, 3])
  inspect(ends, content="true")
}

#Utilities

Additional array utilities for common operations:

///|
test "utilities" {
  // Join string array
  let words = ["hello", "world"]
  let joined = words.join(" ")
  inspect(joined, content="hello world")

  // Random shuffling
  let nums = [1, 2, 3, 4, 5]
  // Using deterministic `rand` function below for demonstration
  // NOTE: When using a normal `rand` function, the actual result may vary
  let shuffled = nums.shuffle(rand=_ => 1)
  debug_inspect(shuffled, content="[1, 3, 4, 5, 2]")
}

View

source

using @moonbitlang/core/builtin { type ArrayView as View }

A ArrayView represents a view into a section of an array without copying the data.

Example

test {
  let arr = [1, 2, 3, 4, 5]
  let view = arr[1:4] // Creates a view of elements at indices 1,2,3
  inspect(view[0], content="2")
  inspect(view.length(), content="3")
}

zip_with

source

fn[A, B, C] zip_with(l : Array[A], r : Array[B], merge : (A, B) -> C raise?) -> Array[C] raise?

Zips two arrays into a single array by applying a function to each pair of elements.

Parameters:

l : The first array.
r : The second array.
merge : A function that takes two arguments, one from each array, and returns a value.

Returns an array containing the results of applying the function to each pair of elements.

Example:

test {
  let arr1 = [1, 2, 3]
  let arr2 = [4, 5, 6]
  let add = (a, b) => a + b
  debug_inspect(@array.zip_with(arr1, arr2, add), content="[5, 7, 9]")
}

Source Files

Site source Report issue Packages Build queue Skills Statistics