057sym.test

(test "sym works with one arg"
  :valueof (sym "abc")
  :should be 'abc)

(test "sym works on empty string"
  :valueof (sym "")
  :should be_false)

(test "sym works with multiple args"
  :valueof (string+sym "abc" 42 :def)  # keyword retains colon
  :should be "abc42:def")

(test "keyword? works"
  :valueof (keyword? 'abc)
  :should be_false)

(test "keyword? works - 2"
  :valueof (keyword? :abc)
  :should be_true)

(test "sym converts keywords"
  :valueof (sym :abc)
  :should be 'abc)  # keyword loses colon

(test "< works with syms"
  :valueof (< "a" 'b)
  :should be_true)

(test "< treats false as a special-case"
  :valueof (< false "g")
  :should be_false)

(test "sort works on lists of syms"
  :valueof (sort (< car) '((b 1) (c 2) (a 3)))
  :should be '((a 3) (b 1) (c 2)))



(test "match? treats any sym beginning with _ as wildcard"
  :valueof (match? '(1 ... _x) '(1 2 3))
  :should be_true)

(test "match? manages _sym identity"
  :valueof (match? '(1 _x _x) '(1 2 3))
  :should be_false)

(test "match? manages _sym identity - 2"
  :valueof (match? '(1 _x _x) '(1 2 2))
  :should be_true)

(test "match? matches $vars with their root"
  :valueof (match? 'a_ 'a3)
  :should be_true)

(test "match? matches $vars with their root - 2"
  :valueof (match? 'a_ 'a)
  :should be_false)

(test "match? manages $var_sym identity"
  :valueof (match? '(a_x a_x) '(a3 a3))
  :should be_true)

(test "match? manages $var_sym identity - 2"
  :valueof (match? '(a_x a_x) '(a2 a3))
  :should be_false)

(test "match? manages $var_sym identity - 3"
  :valueof (match? '(a_x a_x) '(a a3))
  :should be_false)

(test "match integrates with test"
  :valueof (list 'a3 'a3)
  :should match '(a_x a_x))

(test "root works"
  :valueof (root 'a3)
  :should be 'a)