stringify! and assert!

Built-in stringify! and a dbg! macro that shows the source code alongside the value.

// Feature: `stringify!` — converts an expression into a source string
// Syntax: `stringify!(expr)` — built-in macro
// When to use: assert/debug messages that show the original code, not
// just the value. Pairs beautifully with custom macros.

// `stringify!` captures the syntactic form of the expression.
let s = stringify!(1 + 2 * 3)
print(s)

// expected: 1 + 2 * 3

// Works with identifiers, calls, any expression.
let n = stringify!(hello_world)
print(n)

// expected: hello_world

let call = stringify!(foo(1, 2))
print(call)

// expected: foo(1, 2)

// Useful pattern: dbg! shows "expr = value".
macro dbg(x) {
  print("[dbg] {stringify!($x)} = {$x}")
}


let count = 7
dbg!(count)
dbg!(count * 2)
dbg!(count > 5)
// expected:
// [dbg] count = 7
// [dbg] count * 2 = 14
// [dbg] count > 5 = true

assert! and assert_eq! with automatic failure messages via stringify!.

// Feature: Practical macros — `assert!` and `expect!`
// Syntax: combines `stringify!` with the expression for rich messages
// When to use: inline tests and validations with syntactic context.

// assert!: aborts if the condition is false, showing the original code.
macro assert(cond) {
  if !$cond {
    panic("assertion failed: {stringify!($cond)}")
  }
}


assert!(1 + 1 == 2)
assert!("zolo".len() == 4)
print("all asserts passed")

// expected: all asserts passed

// assert_eq!: equality with a useful message on failure.
macro assert_eq(actual, expected) {
  if $actual != $expected {
    panic("assert_eq failed: {stringify!($actual)} != {$expected}, got {$actual}")
  }
}


let result = 2 * 21
assert_eq!(result, 42)
print("ok")
// expected: ok