#Sexp for MoonBit

#S-Expression Format Specification

#Atoms

• Symbols: Sequences of characters excluding whitespace and delimiters ()";.
  • Examples: foo, bar-baz, +, <=, 123?.
  • Note: A lone - is parsed as a Symbol.
• Integers: Signed 64-bit integers.
  • Examples: 123, +42, -99.
• Doubles: Floating point numbers.
  • Examples: 3.14, -0.001, 1.2e10.
• Strings: Enclosed in double quotes. Supports standard escape sequences:
  • \n (newline), \r (CR), \t (tab), \b (backspace), \f (formfeed).
  • \" (quote), \\ (backslash).
  • \uXXXX (unicode codepoint).
• Booleans: #t (true) and #f (false).
• Characters: Prefixed with #\.
  • Literal char: #\a, #\Z.
  • Unicode: #\u00A9.
  • Constants: #\space, #\newline, #\tab, #\return, #\backspace, #\nul.

#Structure

• Lists: Enclosed in parentheses ( ... ).
  • Example: (1 2 "three" (nested 4)).

#Comments

• Line Comments: Start with ; and continue to the end of the line.
  • Example: ; This is a comment.
• S-expression Comments: #; discards the immediately following S-expression.
  • Example: (1 #; (ignored 2 3) 4) parses as (1 4).

#Installation

{
  "import": [
    "sennenki/sexp"
  ]
}

#Parsing

///|
test "parsing" {
  let s = "(list 1 2 3)"
  // Parse returns a Result, use `try!` to unwrap
  let sexp = parse(s)
  inspect(sexp, content="(list 1 2 3)")
}

///|
test "parsing multiple" {
  let s = "1 2 3"
  let sexps = try! parse_many(s)
  inspect(sexps, content="[1, 2, 3]")
}

#Type Conversion

///|
test "conversion" {
  let val = [1, 2, 3]
  // Convert to Sexp
  let sexp = to_sexp(val)
  inspect(sexp, content="(1 2 3)")

  // Convert back
  let back : Array[Int] = try! from_sexp(sexp)
  inspect(back, content="[1, 2, 3]")
}

#Custom Types

///|
struct User {
  name : String
  age : Int
} derive(Show, Eq)

///|
impl ToSexp for User with to_sexp(self) {
  List([Symbol(Symbol::new("user")), String(self.name), Int(self.age)])
}

///|
impl FromSexp for User with from_sexp(sexp, path) {
  match sexp {
    List([Symbol(s), String(name), Int(age)]) =>
      // Note: Symbol comparison should ideally check interned ID if possible,
      // or use the derived Eq.
      if s == Symbol::new("user") {
        { name, age }
      } else {
        raise SexpError("Expected 'user' symbol", path)
      }
    _ => raise SexpError("Invalid user format", path)
  }
}

///|
test "custom type" {
  let user = { name: "Alice", age: 30 }
  let sexp = to_sexp(user)
  inspect(sexp, content="(user \"Alice\" 30)")
  let back : User = try! from_sexp(sexp)
  assert_eq(back, user)
}

#Error Handling

///|
test "error handling" {
  let sexp = Sexp::List([String("not-user"), Int(42)])
  // Attempting to decode into User
  let result : Result[User, SexpError] = try! from_sexp(sexp)
  // You can inspect the error path to find where it failed
  inspect(result, content="Err(SexpError at : Invalid user format)")
}