feat(lisp): triage tier 6 core candidates (#942)

* feat(lisp): triage tier 6 core candidates

Add small Clojure core compatibility aliases for Tier 6 audit items, including arbitrary-precision arithmetic aliases, array-map, hash-set, nthrest/nthnext, ==, and parse-boolean. Mark the remaining low-value/JVM-specific candidates as not relevant and regenerate the function reference and Clojure core audit docs.

Verified with:
- mix test test/ptc_runner/lisp/parser_test.exs test/ptc_runner/lisp/runtime_arithmetic_test.exs test/ptc_runner/lisp/runtime/special_values_test.exs test/ptc_runner/lisp/integration/collection_ops_test.exs --max-failures 5
- mix test test/ptc_runner/lisp/registry_test.exs test/readme_test.exs --max-failures 5
- mix test --max-failures 10

* fix(lisp): address core candidate review

Normalize nthrest/nthnext through seqable conversion, align var-reader symbol parsing with normal symbols, and return a structured arity error for zero-arity -'.

Verified with targeted Lisp parser/collection/arithmetic suites, related arity/bitwise regressions, and full mix test before rebase.

* fix(lisp): address PR #942 review suggestions

- DIV-18 doc: add parse-boolean alongside parse-long/parse-double
- array-map: produce correct error message (was saying hash-map)
- ==: document non-numeric acceptance divergence from Clojure (DIV-10)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 3 people

docs/clojure-conformance-gaps.md

@@ -398,7 +398,7 @@ No `:pre`/`:post` condition maps in `defn`. Without exception handling, assertio
 
 **Rationale:** Matches Clojure. Ambiguous which `%` refers to which scope.
 
-### DIV-18: `parse-long`/`parse-double` return `nil` for non-string input
+### DIV-18: `parse-long`/`parse-double`/`parse-boolean` return `nil` for non-string input
 
 | Field | Value |
 |-------|-------|
@@ -408,10 +408,14 @@ No `:pre`/`:post` condition maps in `defn`. Without exception handling, assertio
 
 ```clojure
 ;; Clojure 1.11+
-(parse-long 42)   ;=> IllegalArgumentException
+(parse-long 42)      ;=> IllegalArgumentException
+(parse-double 42)    ;=> IllegalArgumentException
+(parse-boolean 42)   ;=> IllegalArgumentException
 
 ;; PTC-Lisp
-(parse-long 42)   ;=> nil
+(parse-long 42)      ;=> nil
+(parse-double 42)    ;=> nil
+(parse-boolean 42)   ;=> nil
 ```
 
 **Rationale:** No exception handling (DIV-10). Returning `nil` is safer for LLM-generated code.

docs/clojure-core-audit.md

@@ -4,7 +4,7 @@
 > **Warning:** This file is auto-generated by `mix ptc.gen_docs` from `priv/functions.exs`.
 > Manual edits will be overwritten. Edit `priv/functions.exs` instead.
 
-292 functions and special forms.
+308 functions and special forms.
 
 See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelines](ptc-lisp-design-guidelines.md) | [Clojure Core](clojure-core-audit.md) | [Clojure String](clojure-string-audit.md) | [Clojure Set](clojure-set-audit.md) | [Java Math](java-math-audit.md)
 
@@ -15,11 +15,12 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 - [Threading Macros](#threading-macros) (7)
 - [Control Flow](#control-flow) (4)
 - [Iteration](#iteration) (2)
-- [Core](#core) (167)
+- [Core](#core) (177)
+- [Predicate Builders](#predicate-builders) (4)
 - [Functional Tools](#functional-tools) (3)
 - [Agent Control](#agent-control) (5)
-- [String Functions](#string-functions) (24)
-- [Set Operations](#set-operations) (9)
+- [String Functions](#string-functions) (25)
+- [Set Operations](#set-operations) (10)
 - [Regex Functions](#regex-functions) (6)
 - [Math Functions](#math-functions) (24)
 - [Interop](#interop) (18)
@@ -98,16 +99,21 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 | Function | Signature | Description |
 |----------|-----------|-------------|
 | `*` | `(* x y ...)` | Multiplication |
+| `*'` | `(*' x y ...)` | Arbitrary precision multiplication alias |
 | `+` | `(+ x y ...)` | Addition |
+| `+'` | `(+' x y ...)` | Arbitrary precision addition alias |
 | `-` | `(- x y ...)` | Subtraction |
+| `-'` | `(-' x y ...)` | Arbitrary precision subtraction alias |
 | `/` | `(/ x y)` | Division (always returns float) |
 | `<` | `(< x y)` | Less than |
 | `<=` | `(<= x y)` | Less or equal |
 | `=` | `(= x y)` | Equality |
+| `==` | `(== x y)` | Type-independent numeric equality |
 | `>` | `(> x y)` | Greater than |
 | `>=` | `(>= x y)` | Greater or equal |
 | `NaN?` | `(NaN? ...)` |  |
 | `apply` | `(apply f coll)` | Applies function `f` to the argument sequence `coll` |
+| `array-map` | `(array-map & kvs)` | Create map from alternating key-value pairs |
 | `assoc` | `(assoc m key val)` | Add/update key |
 | `assoc-in` | `(assoc-in m path val)` | Add/update nested |
 | `associative?` | `(associative? ...)` |  |
@@ -129,6 +135,7 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 | `count` | `(count coll)` | Number of items |
 | `counted?` | `(counted? ...)` |  |
 | `dec` | `(dec x)` | Subtract 1 |
+| `dec'` | `(dec' x)` | Arbitrary precision decrement alias |
 | `decimal?` | `(decimal? ...)` |  |
 | `dedupe` | `(dedupe coll)` | Remove consecutive duplicates |
 | `dissoc` | `(dissoc m key)` | Remove key |
@@ -164,6 +171,7 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 | `identity` | `(identity x)` | Returns argument unchanged |
 | `ifn?` | `(ifn? ...)` |  |
 | `inc` | `(inc x)` | Add 1 |
+| `inc'` | `(inc' x)` | Arbitrary precision increment alias |
 | `indexed?` | `(indexed? ...)` |  |
 | `infinite?` | `(infinite? ...)` |  |
 | `int?` | `(int? ...)` |  |
@@ -205,6 +213,8 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 | `not-every?` | `(not-every? :key coll)` | True if not all have truthy `:key` |
 | `not=` | `(not= x y)` | Inequality |
 | `nth` | `(nth coll idx)` | Item at index or nil |
+| `nthnext` | `(nthnext coll n)` | Drop n items and return seq or nil |
+| `nthrest` | `(nthrest coll n)` | Drop n items |
 | `number?` | `(number? ...)` |  |
 | `odd?` | `(odd? ...)` |  |
 | `partial` | `(partial f arg1 ...)` | Returns a function with some arguments pre-filled |
@@ -270,6 +280,10 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 ;; => %{}
 (hash-map :a 1 :b 2)
 ;; => {:a 1, :b 2}
+(array-map)
+;; => %{}
+(array-map :a 1 :b 2)
+;; => {:a 1, :b 2}
 ```
 
 
@@ -310,6 +324,7 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 | `last-index-of` | `(last-index-of s value), (last-index-of s value from-index)` | Index of last occurrence up to position |
 | `lower-case` | `(lower-case ...)` |  |
 | `name` | `(name x)` | Returns name string of keyword or string |
+| `parse-boolean` | `(parse-boolean s)` | Parse string to boolean |
 | `parse-double` | `(parse-double ...)` |  |
 | `parse-int` | `(parse-int ...)` |  |
 | `parse-long` | `(parse-long ...)` |  |
@@ -324,6 +339,12 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 | `upcase` * | `(upcase ...)` |  |
 | `upper-case` | `(upper-case ...)` |  |
 
+```clojure
+(parse-boolean "true")
+;; => true
+(parse-boolean "false")
+;; => false
+```
 
 
 ## Set Operations
@@ -333,13 +354,18 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 | `contains?` | `(contains? coll key)` | True if key/element exists (maps, sets, lists) |
 | `difference` | `(clojure.set/difference & sets)` | Returns the difference of one or more sets |
 | `disj` | `(disj set x ...)` | Remove elements from set |
+| `hash-set` | `(hash-set & items)` | Create set from arguments |
 | `intersection` | `(clojure.set/intersection & sets)` | Returns the intersection of one or more sets |
 | `set` | `(set coll)` | Convert collection to set |
 | `set?` | `(set? x)` | Returns true if x is a set |
 | `union` | `(clojure.set/union & sets)` | Returns the union of zero or more sets |
 | `vec` | `(vec coll)` | Convert collection to vector |
 | `vector` | `(vector & args)` | Create vector from arguments |
 
+```clojure
+(hash-set 1 1 2)
+;; => #{1 2}
+```
 
 
 ## Regex Functions
@@ -427,4 +453,3 @@ See also: [PTC-Lisp Specification](ptc-lisp-specification.md) | [Design Guidelin
 | `mcp/json` | `(mcp/json result)` | Extract typed JSON from an MCP tool-result envelope. Returns structuredContent if set, else parses content[0].text. |
 | `mcp/text` | `(mcp/text result)` | Extract content[0].text from an MCP tool-result envelope; nil for any non-conforming input. |
 
-

docs/function-reference.md

@@ -184,6 +184,8 @@ defmodule PtcRunner.Lisp.Env do
       {:nnext, {:normal, &Runtime.nnext/1}},
       {:take, {:normal, &Runtime.take/2}},
       {:drop, {:normal, &Runtime.drop/2}},
+      {:nthrest, {:normal, &Runtime.nthrest/2}},
+      {:nthnext, {:normal, &Runtime.nthnext/2}},
       {:"take-while", {:normal, &Runtime.take_while/2}},
       {:"drop-while", {:normal, &Runtime.drop_while/2}},
       {:"take-last", {:normal, &Runtime.take_last/2}},
@@ -292,6 +294,11 @@ defmodule PtcRunner.Lisp.Env do
       {:quot, {:normal, &Runtime.Math.quot/2}},
       {:inc, {:normal, &Runtime.inc/1}},
       {:dec, {:normal, &Runtime.dec/1}},
+      {:"+'", {:collect, &Runtime.Math.add/1}},
+      {:"-'", {:collect, &Runtime.Math.subtract/1}},
+      {:"*'", {:collect, &Runtime.Math.multiply/1}},
+      {:"inc'", {:normal, &Runtime.inc/1}},
+      {:"dec'", {:normal, &Runtime.dec/1}},
       {:abs, {:normal, &Runtime.abs/1}},
       {:max, {:variadic_nonempty, :max, &Runtime.Math.max/2}},
       {:min, {:variadic_nonempty, :min, &Runtime.Math.min/2}},
@@ -324,6 +331,7 @@ defmodule PtcRunner.Lisp.Env do
       # Comparison — normal (binary)
       # ============================================================
       {:=, {:normal, &Runtime.Math.eq/2}},
+      {:==, {:normal, &Runtime.Math.eq/2}},
       {:"not=", {:normal, &Runtime.Math.not_eq/2}},
       {:>, {:normal, &Runtime.gt/2}},
       {:<, {:normal, &Runtime.lt/2}},
@@ -373,6 +381,8 @@ defmodule PtcRunner.Lisp.Env do
       # reach for Clojure's `list`. Returning a vector keeps semantics uniform.
       {:list, {:collect, &Function.identity/1}},
       {:"hash-map", {:collect, &Runtime.hash_map/1}},
+      {:"array-map", {:collect, &Runtime.array_map/1}},
+      {:"hash-set", {:collect, &Runtime.hash_set/1}},
       {:map?, {:normal, &Runtime.map?/1}},
       {:coll?, {:normal, &Runtime.coll?/1}},
       {:sequential?, {:normal, &Runtime.sequential?/1}},
@@ -418,6 +428,7 @@ defmodule PtcRunner.Lisp.Env do
       {:"parse-long", {:normal, &Runtime.parse_long/1}},
       {:"parse-int", {:normal, &Runtime.parse_long/1}},
       {:"parse-double", {:normal, &Runtime.parse_double/1}},
+      {:"parse-boolean", {:normal, &Runtime.parse_boolean/1}},
 
       # ============================================================
       # JSON builtins (Plans/json-support.md §4)

lib/ptc_runner/lisp/env.ex

@@ -17,6 +17,7 @@ defmodule PtcRunner.Lisp.Eval.Apply do
   alias PtcRunner.Lisp.Eval.Context, as: EvalContext
   alias PtcRunner.Lisp.Eval.Helpers
   alias PtcRunner.Lisp.Eval.Patterns
+  alias PtcRunner.Lisp.ExecutionError
   alias PtcRunner.Lisp.Format
   alias PtcRunner.Lisp.Runtime.Math
   alias PtcRunner.SubAgent.Namespace.TypeVocabulary
@@ -263,6 +264,10 @@ defmodule PtcRunner.Lisp.Eval.Apply do
     push_side_effect_stash()
     result = fun.(converted_args)
     {:ok, result, pop_side_effects(eval_ctx)}
+  rescue
+    e in ExecutionError ->
+      pop_side_effects(eval_ctx)
+      {:error, execution_error_tuple(e)}
   end
 
   # Multi-arity builtins: select function based on argument count
@@ -678,6 +683,12 @@ defmodule PtcRunner.Lisp.Eval.Apply do
     end
   end
 
+  defp execution_error_tuple(%ExecutionError{reason: reason, message: message, data: nil}),
+    do: {reason, message}
+
+  defp execution_error_tuple(%ExecutionError{reason: reason, message: message, data: data}),
+    do: {reason, message, data}
+
   # ============================================================
   # Closure Execution Helpers
   # ============================================================

lib/ptc_runner/lisp/eval/apply.ex

@@ -32,7 +32,8 @@ defmodule PtcRunner.Lisp.Parser do
   # Character classes for lookahead
   # Note: . is allowed for Clojure-style namespaces like clojure.string/join
   # Note: & is allowed for rest pattern destructuring [a & rest]
-  symbol_rest = [?a..?z, ?A..?Z, ?0..?9, ?+, ?-, ?*, ?/, ?<, ?>, ?=, ??, ?!, ?_, ?%, ?., ?&]
+  # Note: ' is allowed after the first character for Clojure core names like inc'
+  symbol_rest = [?a..?z, ?A..?Z, ?0..?9, ?+, ?-, ?*, ?/, ?<, ?>, ?=, ??, ?!, ?_, ?%, ?., ?&, ?']
 
   nil_literal =
     string("nil")
@@ -188,10 +189,8 @@ defmodule PtcRunner.Lisp.Parser do
   defcombinatorp(
     :var_reader,
     ignore(string("#'"))
-    |> ascii_string([?a..?z, ?A..?Z, ?+, ?-, ?*, ?/, ?<, ?>, ?=, ??, ?!, ?_], 1)
-    |> optional(
-      ascii_string([?a..?z, ?A..?Z, ?0..?9, ?+, ?-, ?*, ?/, ?<, ?>, ?=, ??, ?!, ?_], min: 1)
-    )
+    |> ascii_string(symbol_first, 1)
+    |> optional(ascii_string(symbol_rest, min: 1))
     |> reduce({ParserHelpers, :build_var, []})
   )
 

lib/ptc_runner/lisp/parser.ex

@@ -70,6 +70,8 @@ defmodule PtcRunner.Lisp.Runtime do
   defdelegate nnext(coll), to: Collection
   defdelegate take(n, coll), to: Collection
   defdelegate drop(n, coll), to: Collection
+  defdelegate nthrest(coll, n), to: Collection
+  defdelegate nthnext(coll, n), to: Collection
   defdelegate take_while(pred, coll), to: Collection
   defdelegate drop_while(pred, coll), to: Collection
   defdelegate distinct(coll), to: Collection
@@ -125,6 +127,7 @@ defmodule PtcRunner.Lisp.Runtime do
   defdelegate range(start, end_val), to: Collection
   defdelegate range(start, end_val, step), to: Collection
   defdelegate combinations(coll, n), to: Collection
+  defdelegate hash_set(args), to: Collection
 
   # Tree Traversal
   defdelegate walk(inner, outer, form), to: Collection
@@ -163,6 +166,7 @@ defmodule PtcRunner.Lisp.Runtime do
   defdelegate reduce_kv(f, init, m), to: MapOps
   defdelegate zipmap(keys, vals), to: MapOps
   defdelegate hash_map(args), to: MapOps
+  defdelegate array_map(args), to: MapOps
 
   # ============================================================
   # Arithmetic
@@ -265,6 +269,7 @@ defmodule PtcRunner.Lisp.Runtime do
 
   defdelegate parse_long(s), to: RuntimeString
   defdelegate parse_double(s), to: RuntimeString
+  defdelegate parse_boolean(s), to: RuntimeString
 
   # ============================================================
   # Regex Operations

lib/ptc_runner/lisp/runtime.ex

@@ -241,6 +241,9 @@ defmodule PtcRunner.Lisp.Runtime.Collection do
     coll |> Enum.drop(n) |> Enum.map(fn {k, v} -> [k, v] end)
   end
 
+  def nthrest(coll, n), do: Enum.drop(Normalize.to_seq(coll), max(n, 0))
+  def nthnext(coll, n), do: coll |> nthrest(n) |> seq()
+
   # ============================================================
   # Distinct
   # ============================================================
@@ -253,6 +256,8 @@ defmodule PtcRunner.Lisp.Runtime.Collection do
   # Construction
   # ============================================================
 
+  def hash_set(args) when is_list(args), do: MapSet.new(args)
+
   def concat2(a, b) do
     a = a || []
     b = b || []

lib/ptc_runner/lisp/runtime/collection.ex

@@ -23,6 +23,17 @@ defmodule PtcRunner.Lisp.Runtime.MapOps do
       iex> PtcRunner.Lisp.Runtime.MapOps.hash_map([:a, 1, :b, 2])
       %{a: 1, b: 2}
   """
+  def array_map(args) when is_list(args) do
+    if rem(length(args), 2) != 0 do
+      raise ExecutionError,
+        message: "array-map requires an even number of arguments, got #{length(args)}"
+    end
+
+    args
+    |> Enum.chunk_every(2)
+    |> Enum.into(%{}, fn [k, v] -> {k, v} end)
+  end
+
   def hash_map(args) when is_list(args) do
     if rem(length(args), 2) != 0 do
       raise ExecutionError,

lib/ptc_runner/lisp/runtime/map_ops.ex

@@ -29,6 +29,8 @@ defmodule PtcRunner.Lisp.Runtime.Math do
 
   def add(x, y), do: add([x, y])
 
+  def subtract([]), do: arity_error("-'")
+
   def subtract([x]) do
     case x do
       :nan -> :nan