#Prelude

Example

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

Usage

  let buf = Buffer(size_hint=100)
  buf.write_string_utf16le("Tes")
  buf.write_char_utf16le('t')
  inspect(
    buf.contents(),
    content=(

  #|b"T\x00e\x00s\x00t\x00"

    ),
  )

• zero, if the two arguments are equal
• negative, if the first argument is smaller
• positive, if the first argument is greater

• message : A string describing the nature of the failure.

test {
  let err : Failure = Failure("Test assertion failed")
  match err {
    Failure(msg) => inspect(msg, content="Test assertion failed")
  }
  @json.json_inspect(err, content=["Failure", "Test assertion failed"])
}

test {
  let hasher = Hasher(seed=0)
  hasher.combine_int(42)
  hasher.combine_string("hello")
  inspect(hasher.finalize(), content="860601284")
}

test {
  let x : Int = 42
  inspect(x, content="42") // Raises InspectError with detailed failure message
}

test {
  let value : Json = Json::array([Json::number(1.0), Json::null()])
  inspect(value.stringify(), content="[1,null]")
}

Why force is non-raising / non-async

• No raise. A raising thunk would make force raise too, which would then leak into every consumer that touches a lazy cell — and any data structure built on top (lazy lists, lazy trees, memoized graph nodes) would inherit the effect at every traversal point. Memoizing the failure also forces a choice between "cache the exception and re-raise on every retry" (OCaml-style) and "retry on each force" (Rust-style); both are defensible but neither is obviously right. The recommended pattern for a fallible deferred computation is to make the failure data: Lazy(() => try? f()) produces a Lazy[Result[A, Error]], and the consumer handles the result at the call site it controls.

• No async. Async memoization additionally needs an in-flight state to handle two coroutines racing to force the same cell, which would pull a concurrency primitive into a type whose only job is to delay a value. The right tool for an async deferred value is the language's promise/future type (which already gives "compute once, await many"), not a thunk wrapper.

Concurrency

Example

test {
  let map = { 3: "three", 8: "eight", 1: "one" }
  @test.assert_eq(map.get(2), None)
  @test.assert_eq(map.get(3), Some("three"))
  map.set(3, "updated")
  @test.assert_eq(map.get(3), Some("updated"))
}

Example

test {
  let arr = [1, 2, 3, 4, 5]
  let view = arr.mut_view(start=1, end=4) // Creates a view of elements at indices 1,2,3
  @test.assert_eq(view[0], 2)
  @test.assert_eq(view.length(), 3)
}

test {
  let x = @ref.Ref(42)
  @test.assert_eq(x.val, 42)
  x.val = 100
  @test.assert_eq(x.val, 100)
}

Example

test {
  let set = @set.Set(["three", "eight", "one"])
  @test.assert_eq(set.contains("two"), false)
  @test.assert_eq(set.contains("three"), true)
  set.add("three") // no effect since it already exists
  set.add("two")
  @test.assert_eq(set.contains("two"), true)
}

test {
  let err : SnapshotError = SnapshotError("failed to load snapshot")
  match err {
    SnapshotError(msg) => @test.assert_eq(msg, "failed to load snapshot")
  }
}

• condition : The boolean condition to test.
• location : The source location where the assertion is made. Used in error messages.

test {
  assert_false(false)
  assert_false(1 > 2)
}

• condition : The boolean value to be checked.
• location : The source location where the assertion is made. Defaults to the current location.

test {
  assert_true(true)
}

test {
  inspect(compare(1, 2).is_neg(), content="true")
  inspect(compare("abc", "abc"), content="0")
}

• x : A thunk that computes the condition to check.

• obj: The object to inspect. Must implement the Debug trait.
• content: The expected string representation of the object. Defaults to an empty string if not provided.
• loc: Source code location information for error reporting. Automatically provided by the compiler.
• args_loc: Location information for function arguments in the source code. Automatically provided by the compiler.

test {
  @debug.debug_inspect(42, content="42")
  @debug.debug_inspect('c', content="'c'")
  @debug.debug_inspect(
    "hello",
    content=(
      #|"hello"
    ),
  )
  @debug.debug_inspect(
    ([1, 2, 3, 4], "string", Some(3.14)),
    content=(
      #|([1, 2, 3, 4], "string", Some(3.14))
    ),
  )
}

• message : A string containing the error message to be included in the failure.
• location : The source code location where the failure occurred. Automatically provided by the compiler when not specified.

test {
  inspect(hash(42) == hash(42), content="true")
}

• value : The value to be ignored. Can be of any type.

test {
  let x = 42
  ignore(x) // Explicitly ignore the value
  let mut sum = 0
  ignore(1, 2, 3.each(x => sum  x)) // Ignore the Unit return value of each()
  inspect(sum, content="6")
}

• object : The object to be inspected. Must implement the Show trait.
• content : The expected string representation of the object. Defaults to an empty string.
• location : Source code location information for error reporting. Automatically provided by the compiler.
• arguments_location : Location information for function arguments in source code. Automatically provided by the compiler.

test {
  inspect(42, content="42")
  inspect("hello", content="hello")
  debug_inspect([1, 2, 3], content="[1, 2, 3]")
}

• value : The boolean value to negate.

• first : The first value to compare.
• second : The second value to compare.
• T : The type parameter representing the type of values being compared.

test {
  let arr1 = [1, 2, 3]
  let arr2 = arr1
  let arr3 = [1, 2, 3]
  inspect(physical_equal(arr1, arr2), content="true") // Same object
  inspect(physical_equal(arr1, arr3), content="false") // Different objects with same content
}

• value : The value to be printed. Must implement the Show trait.

test {
  if false {
    println(42)
    println("Hello, World!")
  }
}

Examples

test {
  let str = @debug.to_string([1, 2, 3])
  @test.assert_eq(str, "[1, 2, 3]")
  // Same function under a shorter name.
  @test.assert_eq(repr("hi"), "\"hi\"")
}

Parameters

• value: The value to pass to the function.
• f: The function to apply to the value.

Returns

Parameters

• value: The value to pass to the function.
• f: The function to apply to the value.

Returns

Examples

test {
  let x = 5
  let result = x |> n => { n * 2 }
  @test.assert_eq(result, 10)
}

test {
  try {
    let _ : Unit = 5 |> x => { fail(x.to_string()) }
  } catch {
    Failure(_) => ()
  } noraise {
    _ => fail("expected failure")
  }
}