<!-- Auto-generated — do not edit by hand -->
# Clojure Core Audit for PTC-Lisp

> **Warning:** This file is auto-generated by `mix ptc.gen_docs` from `priv/function_audit.exs`.
> Manual edits will be overwritten. Edit `priv/function_audit.exs` instead.

Comparison of `clojure.core` vars against PTC-Lisp builtins.

See also: [Function Reference](../function-reference.md) | [Namespace Coverage](index.md) | [Clojure String Audit](clojure-string-audit.md) | [Clojure Set Audit](clojure-set-audit.md) | [Clojure Walk Audit](clojure-walk-audit.md) | [Java Math Audit](java-math-audit.md) | [Java Boolean Audit](java-lang-boolean-audit.md) | [Java Double Audit](java-lang-double-audit.md) | [Java Float Audit](java-lang-float-audit.md) | [Java Integer Audit](java-lang-integer-audit.md) | [Java Long Audit](java-lang-long-audit.md) | [Java String Audit](java-lang-string-audit.md) | [Java System Audit](java-lang-system-audit.md) | [Java LocalDate Audit](java-time-local-date-audit.md) | [Java Instant Audit](java-time-instant-audit.md) | [Java Duration Audit](java-time-duration-audit.md) | [Java Period Audit](java-time-period-audit.md) | [Java Date Audit](java-util-date-audit.md)

## Summary

Coverage excludes `not_relevant` entries: `supported / (supported + candidate + not_classified)`.

| Status | Count |
|--------|-------|
| Supported | 235 |
| Candidate | 14 |
| Not Relevant | 286 |
| Not Classified | 0 |
| Relevant Target | 249 |
| Coverage | 235/249 (94.4%) |
| **Total** | **535** |

## Details

| Var | Status | Description | Notes |
|-----|--------|-------------|-------|
| `*` | ✅ supported | Multiplies numbers; returns 1 with no args |  |
| `*'` | ✅ supported | Multiplies numbers with arbitrary precision | alias for *; BEAM integers are already arbitrary precision |
| `+` | ✅ supported | Adds numbers; returns 0 with no args |  |
| `+'` | ✅ supported | Adds numbers with arbitrary precision | alias for +; BEAM integers are already arbitrary precision |
| `-` | ✅ supported | Subtracts numbers or negates single argument |  |
| `-'` | ✅ supported | Subtracts numbers with arbitrary precision | alias for -; BEAM integers are already arbitrary precision |
| `->` | ✅ supported | Threads expression as second argument through forms | GAP-S128 fixed: nil thread targets raise as not callable |
| `->>` | ✅ supported | Threads expression as last argument through forms | GAP-S128 fixed: nil thread targets raise as not callable |
| `.` | ❌ not_relevant | Java member access and method calls | Java interop |
| `..` | ❌ not_relevant | Chains member access operations | Java interop |
| `/` | ✅ supported | Divides numbers |  |
| `<` | ✅ supported | Returns true if numbers monotonically increase | DIV-30: ordering predicates use PTC's recoverable total term ordering |
| `<=` | ✅ supported | Returns true if numbers non-decreasing | DIV-30: ordering predicates use PTC's recoverable total term ordering |
| `=` | ✅ supported | Equality comparison | DIV-32: numeric equality is type-independent. BUG GAP-S120: character literals compare equal to one-character strings |
| `==` | ✅ supported | Type-independent numeric equality | alias for numeric equality; BUG GAP-S120: character literals compare equal to strings |
| `>` | ✅ supported | Returns true if numbers monotonically decrease | DIV-30: ordering predicates use PTC's recoverable total term ordering |
| `>=` | ✅ supported | Returns true if numbers non-increasing | DIV-30: ordering predicates use PTC's recoverable total term ordering |
| `NaN?` | ✅ supported | Returns true if number is NaN | DIV-31: returns false for nil/non-numeric inputs instead of raising |
| `abs` | ✅ supported | Returns absolute value of number | DIV-37: uses PTC-Lisp arbitrary-precision integers instead of JVM Long/MIN_VALUE overflow |
| `accessor` | ❌ not_relevant | Returns function accessing structmap value at key | legacy structmap helper; structmaps are not supported |
| `aclone` | ❌ not_relevant | Returns clone of Java array | Java array manipulation |
| `add-tap` | ❌ not_relevant | Adds function to receive tap> values | I/O and global state side effects |
| `add-watch` | ❌ not_relevant | Adds watch function to reference | mutable state and referencing |
| `agent` | ❌ not_relevant | Creates agent with initial value | concurrency primitive (mutable state) |
| `agent-error` | ❌ not_relevant | Returns exception from failed agent | depends on agent state and exception handling |
| `aget` | ❌ not_relevant | Returns value at Java array index | Java interop (Java array access) |
| `alength` | ❌ not_relevant | Returns length of Java array | Java interop (Java array length) |
| `alias` | ❌ not_relevant | Adds namespace alias | namespace manipulation |
| `all-ns` | ❌ not_relevant | Returns all namespaces | namespace system |
| `alter` | ❌ not_relevant | Sets ref value in transaction | concurrency primitive (ref mutation) |
| `alter-meta!` | ❌ not_relevant | Atomically sets metadata via function | metadata and mutability |
| `alter-var-root` | ❌ not_relevant | Atomically alters var root binding | var root mutation |
| `amap` | ❌ not_relevant | Maps expression across Java array | Java interop (Java array iteration) |
| `ancestors` | ❌ not_relevant | Returns parents of tag via hierarchy | relies on Clojure's global hierarchy/multimethod system |
| `and` | ✅ supported | Short-circuit logical AND |  |
| `any?` | 🔲 candidate | Returns true for any argument | pure predicate function |
| `apply` | ✅ supported | Applies function to argument sequence | BUG GAP-S33: nil and string final arguments currently raise instead of acting seqable. A nil function position raises (not callable), matching Clojure. BUG GAP-S13: vector function position is rejected |
| `areduce` | ❌ not_relevant | Reduces expression across Java array | relies on Java array interoperability |
| `array-map` | ✅ supported | Constructs array-map from key-value pairs | alias for hash-map; no separate small-map representation |
| `as->` | ✅ supported | Binds name to expr, threads through forms | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `aset` | ❌ not_relevant | Sets value in Java array at index | performs mutable operations on Java arrays |
| `assert` | ❌ not_relevant | Throws AssertionError if expr false | relies on exception handling/throwing |
| `assoc` | ✅ supported | Returns map/vector with added key-value pairs | The one-arity form raises (assoc requires key/value pairs), matching Clojure |
| `assoc!` | ❌ not_relevant | Sets value in transient collection | relies on transient collections (mutability) |
| `assoc-in` | ✅ supported | Associates value in nested structure | An empty or nil path associates the value at the nil key, matching Clojure's recursive assoc-in definition |
| `associative?` | ✅ supported | Returns true if coll implements Associative | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `atom` | ❌ not_relevant | Creates atom with initial value | relies on mutable state |
| `await` | ❌ not_relevant | Blocks until agent actions complete | relies on agent state |
| `await-for` | ❌ not_relevant | Blocks with timeout for agent actions | relies on agent state |
| `bases` | ❌ not_relevant | Returns immediate superclass and interfaces | Java interop and class inspection |
| `bean` | ❌ not_relevant | Returns map based on JavaBean properties | Java interop (JavaBeans) |
| `bigdec` | ❌ not_relevant | Coerces to BigDecimal | BEAM runtime has no BigDecimal type in PTC-Lisp |
| `bigint` | ❌ not_relevant | Coerces to BigInt | BEAM integers are already arbitrary precision |
| `biginteger` | ❌ not_relevant | Coerces to BigInteger | JVM-specific BigInteger coercion; BEAM integers are already arbitrary precision |
| `binding` | ❌ not_relevant | Binds vars to new values for body duration | relies on thread-local var binding mechanism |
| `bit-and` | ✅ supported | Bitwise AND | integers only; unary forms raise (require at least two arguments), matching Clojure. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-and-not` | ✅ supported | Bitwise AND with complement | integers only; unary forms raise (require at least two arguments), matching Clojure. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-clear` | ✅ supported | Clears bit at index | integers only; BUG GAP-S52: negative or >=64 indexes are not JVM-masked correctly. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-flip` | ✅ supported | Flips bit at index | integers only; BUG GAP-S52: negative or >=64 indexes are not JVM-masked correctly. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-not` | ✅ supported | Bitwise complement | integers only; BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-or` | ✅ supported | Bitwise OR | integers only; unary forms raise (require at least two arguments), matching Clojure. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-set` | ✅ supported | Sets bit at index | integers only; BUG GAP-S52: negative or >=64 indexes are not JVM-masked correctly. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-shift-left` | ✅ supported | Bitwise left shift | integers only; BUG GAP-S52: negative shift counts are rejected instead of JVM-masked. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-shift-right` | ✅ supported | Bitwise right shift | integers only; arithmetic (sign-extending) shift; BUG GAP-S52: negative shift counts are rejected instead of JVM-masked. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-test` | ✅ supported | Tests bit at index | integers only; BUG GAP-S52: negative or >=64 indexes are not JVM-masked correctly. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `bit-xor` | ✅ supported | Bitwise exclusive OR | integers only; unary forms raise (require at least two arguments), matching Clojure. BUG GAP-S142: BigInt operands are accepted instead of raising |
| `boolean` | ✅ supported | Coerces to boolean |  |
| `boolean-array` | ❌ not_relevant | Creates boolean Java array | creates Java array, incompatible with BEAM/non-JVM environments |
| `boolean?` | ✅ supported | Returns true if value is Boolean | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `booleans` | ❌ not_relevant | Casts to boolean array | Java array manipulation |
| `bound-fn` | ❌ not_relevant | Returns function with call-site bindings | relies on thread-local/dynamic scope bindings |
| `bound-fn*` | ❌ not_relevant | Returns function applying creation-context bindings | relies on thread-local/dynamic scope bindings |
| `bound?` | ❌ not_relevant | Returns true if all vars have bound value | relies on dynamic var binding state |
| `bounded-count` | ❌ not_relevant | Counts up to n elements | designed for lazy sequences |
| `butlast` | ✅ supported | Returns all but last item | nil, empty, and singleton sequential/string inputs return nil (Clojure empty-seq punning). BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `byte` | ❌ not_relevant | Coerces to byte | JVM primitive width coercion |
| `byte-array` | ❌ not_relevant | Creates byte Java array | Java array creation |
| `bytes` | ❌ not_relevant | Casts to byte array | Java array casting |
| `bytes?` | ❌ not_relevant | Returns true if value is byte array | Java array type check |
| `case` | ✅ supported | Constant-time dispatch on expression value | BUG GAP-S37: no-match/no-default form currently returns nil instead of raising. BUG GAP-S72: duplicate constants are accepted and compound constants are rejected. BUG GAP-S120: character literals dispatch as equal to one-character strings. DIV-32: numeric dispatch follows PTC's type-independent numeric equality |
| `cast` | ❌ not_relevant | Throws ClassCastException if not instance | relies on Java type system and exception handling |
| `cat` | ❌ not_relevant | Transducer concatenating input collections | transducers are not supported |
| `char` | ❌ not_relevant | Coerces to char | JVM character coercion; PTC-Lisp strings are UTF-8 binaries |
| `char-array` | ❌ not_relevant | Creates char Java array | creates Java array |
| `char?` | ✅ supported | Returns true if value is Character | BUG GAP-S44: one-character strings currently return true |
| `chars` | ❌ not_relevant | Casts to char array | relies on Java char array types |
| `class` | ❌ not_relevant | Returns class of value | relies on Java class introspection |
| `class?` | ❌ not_relevant | Returns true if value is Class instance | relies on Java type system |
| `clojure-version` | ❌ not_relevant | Returns Clojure version string | environment info irrelevant to pure data transformation |
| `coll?` | ✅ supported | Returns true if implements IPersistentCollection |  |
| `comment` | ❌ not_relevant | Ignores body, yields nil | REPL/source code construct |
| `commute` | ❌ not_relevant | Sets ref value via commutative function | mutable state primitive (refs) |
| `comp` | ✅ supported | Composes functions right-to-left | BUG GAP-S71: map/set/vector callables are rejected in composed function position. A nil composed function raises when called (not callable), matching Clojure |
| `comparator` | 🔲 candidate | Returns Comparator from predicate | pure function to create a comparison function |
| `compare` | ✅ supported | Compares values returning neg/zero/pos | DIV-30: uses PTC's recoverable total term ordering for nil, maps, and mixed values; DIV-33: NaN is unordered and raises |
| `compare-and-set!` | ❌ not_relevant | Atomically sets atom if current equals old | operates on mutable state (atoms) |
| `compile` | ❌ not_relevant | Compiles namespace into classfiles | compilation and class generation |
| `complement` | ✅ supported | Returns function with opposite truth value | BUG GAP-S71: map/set callables are rejected in predicate position |
| `completing` | 🔲 candidate | Returns reducing function with completion | pure function for reducing transformations |
| `concat` | ✅ supported | Returns lazy seq concatenating collections | BUG GAP-S57: string inputs currently raise instead of being treated as seqable |
| `cond` | ✅ supported | Multi-way conditional | The zero-clause form returns nil, matching Clojure |
| `cond->` | ✅ supported | Threads through forms where tests true | BUG GAP-S123: trailing unmatched test raises instead of acting as a no-op |
| `cond->>` | ✅ supported | Threads as last arg where tests true | BUG GAP-S123: trailing unmatched test raises instead of acting as a no-op |
| `condp` | ✅ supported | Predicate dispatch against expression | BUG GAP-S38: :>> result-function clauses are unsupported. BUG GAP-S103: no-match/no-default form currently returns nil instead of raising |
| `conj` | ✅ supported | Returns collection with items added | BUG GAP-S76: conjoining a map into a map currently raises instead of merging entries. The zero-arity form returns an empty vector (Clojure's conj identity). BUG GAP-S137: list pairs are treated as map entries instead of raising. DIV-25: nil/list targets use vector append semantics |
| `conj!` | ❌ not_relevant | Adds item to transient collection | operates on transient collections (mutable) |
| `cons` | ✅ supported | Returns seq with item prepended | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `constantly` | ✅ supported | Returns function ignoring args, returning value |  |
| `contains?` | ✅ supported | Returns true if key present in collection | DIV-27 for sequential collections and map entries; returns false for a nil collection (matching Clojure); BUG GAP-S35 on string indexes, including numeric indexes Clojure accepts |
| `count` | ✅ supported | Returns number of items in collection | DIV-36: string counts use Unicode graphemes instead of JVM UTF-16 code units. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `counted?` | ✅ supported | Returns true if constant-time count | BUG GAP-S70: strings currently return true but Clojure returns false |
| `create-ns` | ❌ not_relevant | Creates or returns namespace | requires namespace system |
| `create-struct` | ❌ not_relevant | Returns structure basis object | relies on legacy fixed-key structure system |
| `cycle` | ❌ not_relevant | Returns infinite lazy seq repeating collection | relies on lazy sequences |
| `dec` | ✅ supported | Returns number minus one |  |
| `dec'` | ✅ supported | Decrements with arbitrary precision | alias for dec; BEAM integers are already arbitrary precision |
| `decimal?` | ✅ supported | Returns true if BigDecimal | always false; BigDecimal literals are unsupported, see DIV-20 |
| `declare` | ❌ not_relevant | Defines var names with no bindings | relies on namespace/var system |
| `dedupe` | ✅ supported | Removes consecutive duplicates | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `def` | ✅ supported | Creates and interns global var | BUG GAP-S140: no-init def raises instead of creating an unbound var. BUG GAP-S141: return value omits the user namespace |
| `definterface` | ❌ not_relevant | Creates Java interface | Java interop |
| `defmacro` | ❌ not_relevant | Defines macro | macro system |
| `defmethod` | ❌ not_relevant | Creates multimethod implementation | multimethods |
| `defmulti` | ❌ not_relevant | Creates multimethod with dispatch function | multimethods |
| `defn` | ✅ supported | Defines named function | DIV-15: multi-arity defn is intentionally unsupported. BUG GAP-S118/GAP-S119: parameter destructuring misses associative vector sources and rest key/value coercion |
| `defn-` | ❌ not_relevant | Defines private function | namespacing/metadata |
| `defonce` | ✅ supported | Defines var only if not already defined | BUG GAP-S141: return value omits the user namespace |
| `defprotocol` | ❌ not_relevant | Creates protocol with method signatures | protocols |
| `defrecord` | ❌ not_relevant | Creates record type with fields | custom types/Java-like classes |
| `defstruct` | ❌ not_relevant | Creates structure type | obsolete type system |
| `deftype` | ❌ not_relevant | Creates custom type with fields | custom types/Java interop |
| `delay` | ❌ not_relevant | Defers expression evaluation | lazy evaluation/stateful caching |
| `delay?` | ❌ not_relevant | Returns true if value is delay | relies on delay/concurrency which is not supported |
| `deliver` | ❌ not_relevant | Delivers result to promise | relies on promise/mutable state |
| `denominator` | ❌ not_relevant | Returns denominator of ratio | ratio values are not supported |
| `deref` | ❌ not_relevant | Dereferences ref/delay/future/promise | relies on mutable state/concurrency types |
| `derive` | ❌ not_relevant | Establishes hierarchical relationship | relies on global namespace/hierarchy state |
| `descendants` | ❌ not_relevant | Returns all descendants of tag | relies on global namespace/hierarchy state |
| `disj` | ✅ supported | Returns set with item removed |  |
| `disj!` | ❌ not_relevant | Removes from transient set | relies on transient/mutable data structures |
| `dissoc` | ✅ supported | Returns map with key removed | BUG GAP-S19: nil map root currently raises instead of returning nil |
| `dissoc!` | ❌ not_relevant | Removes from transient map | relies on transient/mutable data structures |
| `distinct` | ✅ supported | Returns seq removing duplicates | BUG GAP-S20: nil input currently raises instead of returning an empty seq. BUG GAP-S134: direct map input returns entries instead of raising |
| `distinct?` | ✅ supported | Returns true if all args distinct | BUG GAP-S64: zero-arity distinct? returns true instead of raising. BUG GAP-S101: repeated NaN values are treated as duplicates |
| `do` | ✅ supported | Evaluates expressions, returns last |  |
| `doall` | ❌ not_relevant | Realizes entire lazy seq | relies on lazy sequences |
| `dorun` | ❌ not_relevant | Realizes lazy seq, returns nil | relies on lazy sequences |
| `doseq` | ✅ supported | Iterates over sequences for side effects | BUG GAP-S18: def side effects inside doseq are not visible after the loop |
| `dosync` | ❌ not_relevant | Executes body in STM transaction | relies on concurrency/STM primitives |
| `dotimes` | ❌ not_relevant | Executes body n times with counter | relies on side-effecting loops |
| `doto` | ❌ not_relevant | Calls methods on object, returns object | relies on Java interop |
| `double` | ✅ supported | Coerces to double |  |
| `double-array` | ❌ not_relevant | Creates double Java array | relies on Java arrays |
| `double?` | ✅ supported | Returns true if Double | BUG GAP-S127: special float literals return false instead of true |
| `doubles` | ❌ not_relevant | Casts to double array | relies on Java arrays |
| `drop` | ✅ supported | Returns seq skipping first n items | BUG GAP-S20: nil input currently raises instead of returning an empty seq; BUG GAP-S32: negative count drops from the end instead of returning the input; BUG GAP-S79: numeric count coercion rejects floats Clojure accepts |
| `drop-last` | ✅ supported | Returns seq without last n items | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `drop-while` | ✅ supported | Drops items while predicate true | BUG GAP-S71: map/vector callables are rejected in predicate position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `eduction` | ❌ not_relevant | Returns reducible wrapper of transducer | relies on lazy/transducer abstractions |
| `empty` | ✅ supported | Returns empty collection of same type | BUG GAP-S56: string input returns an empty string instead of nil. BUG GAP-S88: non-collection inputs should return nil but currently raise or return an empty map |
| `empty?` | ✅ supported | Returns true if collection empty | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `ensure` | ❌ not_relevant | Ensures ref not written by other transaction | relies on software transactional memory (ref/transactional state) |
| `ensure-reduced` | 🔲 candidate | Wraps in reduced if not already | pure utility for reduction flow control |
| `enumeration-seq` | ❌ not_relevant | Lazy seq from Java Enumeration | relies on lazy sequences and Java interop |
| `error-handler` | ❌ not_relevant | Returns agent error handler | relies on agent state |
| `error-mode` | ❌ not_relevant | Returns agent error mode | relies on agent state |
| `eval` | ❌ not_relevant | Evaluates form in current namespace | requires runtime compilation and namespace support |
| `even?` | ✅ supported | Returns true if number is even | DIV-31: numeric predicates return false for non-numeric inputs |
| `every-pred` | ✅ supported | Returns combined predicate (all must be true) | BUG GAP-S71: map/set/vector callables are rejected in predicate position |
| `every?` | ✅ supported | Returns true if pred true for all items | BUG GAP-S71: map/vector callables are rejected in predicate position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `ex-cause` | ❌ not_relevant | Returns cause of exception | relies on exception handling |
| `ex-data` | ❌ not_relevant | Returns data map of exception | relies on exception handling |
| `ex-info` | ❌ not_relevant | Creates exception with message and data | relies on exception handling |
| `ex-message` | ❌ not_relevant | Returns exception message string | relies on exception handling |
| `extend` | ❌ not_relevant | Adds protocol implementations for type | relies on protocols |
| `extend-protocol` | ❌ not_relevant | Extends protocol to types | relies on protocols |
| `extend-type` | ❌ not_relevant | Extends type to implement protocol | relies on protocols |
| `extenders` | ❌ not_relevant | Returns types extending protocol | relies on protocols |
| `extends?` | ❌ not_relevant | Returns true if type extends protocol | relies on protocols |
| `false?` | ✅ supported | Returns true if value is false |  |
| `ffirst` | ✅ supported | First of first item | nil input returns nil, matching Clojure |
| `file-seq` | ❌ not_relevant | Lazy seq of files in directory tree | relies on lazy sequences and file I/O |
| `filter` | ✅ supported | Returns items where predicate true | BUG GAP-S71: map callables are rejected in predicate position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `filterv` | ✅ supported | Returns vector of items where pred true | BUG GAP-S71: map callables are rejected in predicate position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `find` | ✅ supported | Returns map entry for key or nil | DIV-48: non-associative collections (sets, strings) return a recoverable :type_error signal where Clojure raises |
| `find-keyword` | ❌ not_relevant | Returns keyword with ns and name | relies on namespaces |
| `find-ns` | ❌ not_relevant | Returns namespace or nil | relies on namespace system |
| `find-var` | ❌ not_relevant | Returns var or nil | relies on vars/namespace system |
| `first` | ✅ supported | Returns first item | DIV-29: direct map input raises; use seq/entries/keys/vals for ordered map views. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `flatten` | ✅ supported | Flattens nested collections | BUG GAP-S20: nil input currently raises instead of returning an empty seq. BUG GAP-S81: scalar/string/character/map roots raise instead of returning an empty seq |
| `float` | ✅ supported | Coerces to float | BUG GAP-S122: infinite inputs return infinities instead of raising |
| `float-array` | ❌ not_relevant | Creates float Java array | creates Java array |
| `float?` | ✅ supported | Returns true if Float | BUG GAP-S127: special float literals return false instead of true |
| `floats` | ❌ not_relevant | Casts to float array | handles Java arrays |
| `flush` | ❌ not_relevant | Flushes output writer | I/O operation |
| `fn` | ✅ supported | Defines anonymous function | DIV-15: multi-arity fn is intentionally unsupported. BUG GAP-S39: vector destructuring :as patterns are unsupported in params. BUG GAP-S86: map destructuring :syms is unsupported in params. BUG GAP-S87: vector destructuring rejects string inputs in params. BUG GAP-S97: vector rest destructuring binds nil input rest as [] in params. BUG GAP-S118/GAP-S119: parameter destructuring misses associative vector sources and rest key/value coercion |
| `fn?` | ✅ supported | Returns true if value is function |  |
| `fnext` | ✅ supported | First of next item | nil input returns nil, matching Clojure |
| `fnil` | ✅ supported | Returns function with nil defaults | BUG GAP-S42: two- and three-default arities are unsupported. BUG GAP-S71: keyword/map/set/vector callables are rejected in function position |
| `for` | ✅ supported | List comprehension from nested iteration | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `force` | ❌ not_relevant | Forces evaluation of delay | relies on lazy evaluation/delays |
| `format` | ✅ supported | Returns formatted string | DIV-39: %s collection rendering uses deterministic PTC readable formatting. BUG GAP-S65: width/alignment/zero-padding and sign flags are currently ignored or rejected. BUG GAP-S89: boolean and newline conversions are currently rejected. BUG GAP-S96: several Java Formatter conversions and argument indexes are unsupported. BUG GAP-S117: supported numeric conversions reject nil instead of rendering null |
| `frequencies` | ✅ supported | Returns map of item frequencies | BUG GAP-S20: nil input currently raises instead of returning an empty frequency map; direct map input raises instead of counting map entries. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `future` | ❌ not_relevant | Async computation | concurrency primitive |
| `future-call` | ❌ not_relevant | Calls function asynchronously | concurrency primitive |
| `future-cancel` | ❌ not_relevant | Cancels future | concurrency primitive |
| `future-cancelled?` | ❌ not_relevant | Returns true if future cancelled | concurrency primitive |
| `future-done?` | ❌ not_relevant | Returns true if future complete | concurrency primitive |
| `future?` | ❌ not_relevant | Returns true if value is future | concurrency primitive |
| `gensym` | ❌ not_relevant | Returns unique symbol | macro system utility |
| `get` | ✅ supported | Returns value for key or nil | BUG GAP-S12: string indexes and non-index keys currently raise. BUG GAP-S36: set lookup currently raises instead of returning value/default, including nil members |
| `get-in` | ✅ supported | Returns value at nested key path | BUG GAP-S19: nil map root currently raises instead of returning nil/default; BUG GAP-S12: string indexes currently raise; BUG GAP-S36: set roots currently raise instead of using set lookup. A nil path returns the root value, matching Clojure |
| `get-method` | ❌ not_relevant | Returns multimethod implementation | multimethods not supported |
| `get-proxy-class` | ❌ not_relevant | Returns proxy class | Java interop |
| `get-thread-bindings` | ❌ not_relevant | Returns thread-local bindings | concurrency primitive / thread locals |
| `get-validator` | ❌ not_relevant | Returns reference validator | mutable state validator |
| `group-by` | ✅ supported | Groups items by function result | BUG GAP-S67: string inputs are rejected instead of treated as seqable. BUG GAP-S71: map/set/vector callables are rejected or misapplied as key functions |
| `halt-when` | ❌ not_relevant | Transducer halting on predicate | relies on transducers which often involve stateful reduction and lazy-like sequence processing |
| `hash` | ❌ not_relevant | Returns hash code | runtime-specific hash values are not stable across hosts |
| `hash-map` | ✅ supported | Creates hash map from pairs |  |
| `hash-ordered-coll` | ❌ not_relevant | Returns hash of ordered collection | Clojure hashing internals; not stable across PTC-Lisp hosts |
| `hash-set` | ✅ supported | Creates hash set from items | constructs a PTC-Lisp set from variadic arguments |
| `hash-unordered-coll` | ❌ not_relevant | Returns hash of unordered collection | Clojure hashing internals; not stable across PTC-Lisp hosts |
| `ident?` | ❌ not_relevant | Returns true if keyword or symbol | PTC-Lisp has keywords but no first-class symbol or namespaced identifier values |
| `identical?` | ❌ not_relevant | Returns true if same object | relies on object identity which is not meaningful for serializable data in a BEAM-based environment |
| `identity` | ✅ supported | Returns argument unchanged |  |
| `if` | ✅ supported | Conditional branch |  |
| `if-let` | ✅ supported | Conditional with binding | DIV-14: destructuring bindings are intentionally unsupported. BUG GAP-S115: no-else arity is unsupported. BUG GAP-S145: extra binding-vector forms are rejected instead of ignored |
| `if-not` | ✅ supported | Negated conditional |  |
| `if-some` | ✅ supported | Binds if not nil | DIV-14: destructuring bindings are intentionally unsupported. BUG GAP-S115: no-else arity is unsupported. BUG GAP-S145: extra binding-vector forms are rejected instead of ignored |
| `ifn?` | ✅ supported | Returns true if invokable | BUG GAP-S13: vectors are callable in Clojure but not in PTC-Lisp |
| `import` | ❌ not_relevant | Imports Java classes | relies on Java interop |
| `in-ns` | ❌ not_relevant | Changes current namespace | relies on namespace support |
| `inc` | ✅ supported | Returns number plus one |  |
| `inc'` | ✅ supported | Increments with arbitrary precision | alias for inc; BEAM integers are already arbitrary precision |
| `indexed?` | ✅ supported | Returns true if supports indexed access | BUG GAP-S70: strings currently return true but Clojure returns false |
| `infinite?` | ✅ supported | Returns true if number infinite | DIV-31: returns false for nil/non-numeric inputs instead of raising |
| `inst-ms` | ❌ not_relevant | Milliseconds since epoch for instant | covered by existing temporal interop .getTime |
| `inst?` | ❌ not_relevant | Returns true if instant | Clojure instant predicate; PTC-Lisp temporal interop uses host date structs |
| `instance?` | ❌ not_relevant | Returns true if instance of class | relies on Java class system |
| `int` | ✅ supported | Coerces to int |  |
| `int-array` | ❌ not_relevant | Creates int Java array | relies on Java array/mutability |
| `int?` | ✅ supported | Returns true if Integer | DIV-37: arbitrary-precision PTC integers have no distinct JVM int/long width |
| `integer?` | ✅ supported | Returns true if integer |  |
| `interleave` | ✅ supported | Interleaves items from collections | Variadic (0/1/n arity) over lists. BUG GAP-S20: nil inputs currently raise instead of returning an empty seq. BUG GAP-S98: string inputs currently raise instead of being treated as seqable. DIV-29: direct map input raises; use seq/entries/keys/vals for ordered map views. |
| `intern` | ❌ not_relevant | Creates or returns var in namespace | operates on namespaces |
| `interpose` | ✅ supported | Inserts separator between items | Strings are seqable (interposed as characters). DIV-29: direct map input raises; use seq/entries/keys/vals for ordered map views. |
| `into` | ✅ supported | Conjoins items from source into target | BUG GAP-S41: zero/one arities, string sources, and nil targets currently raise instead of following Clojure seq/list behavior |
| `into-array` | ❌ not_relevant | Creates Java array from items | Java interop |
| `ints` | ❌ not_relevant | Casts to int array | Java interop |
| `isa?` | ❌ not_relevant | Returns true if child is parent instance | relies on hierarchy/multimethods system |
| `iterate` | ❌ not_relevant | Lazy seq of repeated function application | creates lazy sequences |
| `iteration` | ❌ not_relevant | Reducible wrapper of iterator | wraps Java iterators |
| `iterator-seq` | ❌ not_relevant | Lazy seq from Java Iterator | creates lazy sequences from Java iterators |
| `juxt` | ✅ supported | Applies multiple functions, collects results | BUG GAP-S58: resulting function currently supports only one call argument. Zero-arity juxt raises (requires at least one function), matching Clojure. BUG GAP-S71: map/set/vector callables are rejected in function position |
| `keep` | ✅ supported | Keeps non-nil results of function | BUG GAP-S71: map/vector callables are rejected in function position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `keep-indexed` | ✅ supported | Keeps non-nil results with index | BUG GAP-S71: map callables are rejected in function position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `key` | ✅ supported | Returns key of map entry | BUG GAP-S17: currently accepts plain vectors/list pairs as map entries |
| `keys` | ✅ supported | Returns map keys | DIV-38: map views are sorted by key instead of preserving Clojure map iteration order |
| `keyword` | ✅ supported | Coerces to keyword | BUG GAP-S34: namespace/name arity is unsupported. BUG GAP-S63: keyword invocation matches string keys. BUG GAP-S78: non-string/non-keyword inputs raise instead of returning nil. DIV-13/DIV-34/DIV-35: namespaced, empty, and broad-character keywords are outside the PTC-Lisp data model. |
| `keyword?` | ✅ supported | Returns true if keyword |  |
| `last` | ✅ supported | Returns last item | nil input returns nil, matching Clojure. DIV-29: direct map input raises; use seq/entries/keys/vals for ordered map views. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `lazy-cat` | ❌ not_relevant | Lazy concatenation of expressions | relies on lazy sequences |
| `lazy-seq` | ❌ not_relevant | Creates lazy sequence from expression | relies on lazy sequences |
| `let` | ✅ supported | Local variable bindings | BUG GAP-S39: vector destructuring :as patterns are unsupported, including after rest bindings. BUG GAP-S86: map destructuring :syms is unsupported. BUG GAP-S87: vector destructuring rejects string inputs. BUG GAP-S97: vector rest destructuring binds nil input rest as []. BUG GAP-S118/GAP-S119: map destructuring rejects associative vector sources and vector rest map destructuring misses key/value coercion |
| `letfn` | ❌ not_relevant | Binds function names for mutual recursion | mutual recursion binding form is outside PTC-Lisp's small evaluator surface |
| `line-seq` | ❌ not_relevant | Lazy seq of lines from reader | relies on lazy sequences and reader I/O |
| `list` | ✅ supported | Alias for vector (PTC-Lisp is vector-first) | implemented as alias for vector |
| `list*` | ❌ not_relevant | Creates list with seq appended | PTC-Lisp is vector-first and has no separate list runtime type |
| `list?` | ❌ not_relevant | Returns true if list | PTC-Lisp is vector-first and has no separate list runtime type |
| `load` | ❌ not_relevant | Loads Clojure file from classpath | relies on file I/O and classpath |
| `load-file` | ❌ not_relevant | Loads Clojure file from path | relies on file I/O |
| `load-reader` | ❌ not_relevant | Loads code from reader | relies on reader I/O |
| `load-string` | ❌ not_relevant | Loads code from string | evaluates code/REPL feature |
| `locking` | ❌ not_relevant | Acquires monitor lock, executes body | concurrency primitive/locking |
| `long` | ❌ not_relevant | Coerces to long | JVM primitive width coercion; use int for integer coercion |
| `long-array` | ❌ not_relevant | Creates long Java array | Java interop/primitive array |
| `longs` | ❌ not_relevant | Casts to long array | Java interop/primitive array |
| `loop` | ✅ supported | Loop with recur for tail recursion | Bodyless form returns nil, matching Clojure |
| `macroexpand` | ❌ not_relevant | Recursively expands macro | macro system |
| `macroexpand-1` | ❌ not_relevant | Expands macro one level | macro system |
| `make-array` | ❌ not_relevant | Creates Java array | Java interop/array creation |
| `make-hierarchy` | ❌ not_relevant | Returns empty hierarchy | relies on multimethods system |
| `map` | ✅ supported | Applies function to each item | BUG GAP-S71: map/vector callables are rejected in function position. BUG GAP-S102: multi-collection arity rejects string inputs. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `map-entry?` | ✅ supported | Returns true if map entry | DIV-49: returns false for every value because PTC-Lisp has no distinct MapEntry type (a map seq entry is the same 2-element vector value as a literal vector) |
| `map-indexed` | ✅ supported | Applies function with index to items | BUG GAP-S71: map callables are rejected in function position |
| `map?` | ✅ supported | Returns true if map |  |
| `mapcat` | ✅ supported | Maps then concatenates results | BUG GAP-S49: multiple input collections, nil results, and string results currently raise. BUG GAP-S71: map callables are rejected in function position |
| `mapv` | ✅ supported | Returns vector from mapping function | BUG GAP-S71: map/vector callables are rejected in function position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `max` | ✅ supported | Returns greatest number | DIV-30: uses PTC's recoverable total term ordering for nil and mixed values |
| `max-key` | ✅ supported | Returns item with greatest function value | DIV-30: key comparison uses PTC's recoverable total term ordering for nil and mixed values. BUG GAP-S47: ties currently return the first maximum instead of the last. BUG GAP-S71: map/vector callables are rejected as key functions |
| `memfn` | ❌ not_relevant | Returns function calling Java method | relies on Java interop |
| `memoize` | ❌ not_relevant | Caches function results by arguments | relies on mutable state for caching |
| `merge` | ✅ supported | Merges maps | BUG GAP-S54: zero-arity and single nil forms return an empty map instead of nil; A single non-map collection is returned unchanged (Clojure semantics). BUG GAP-S90: vector targets are rejected. BUG GAP-S100: direct vector map-entry sources are rejected |
| `merge-with` | ✅ supported | Merges maps with combining function | BUG GAP-S54: no-map and single nil forms return an empty map instead of nil. A single non-map collection is returned unchanged (Clojure semantics). BUG GAP-S90: vector targets are rejected |
| `meta` | ❌ not_relevant | Returns metadata | relies on metadata support |
| `methods` | ❌ not_relevant | Returns multimethod implementations | relies on multimethods |
| `min` | ✅ supported | Returns least number | DIV-30: uses PTC's recoverable total term ordering for nil and mixed values |
| `min-key` | ✅ supported | Returns item with least function value | DIV-30: key comparison uses PTC's recoverable total term ordering for nil and mixed values. BUG GAP-S47: ties currently return the first minimum instead of the last. BUG GAP-S71: map/vector callables are rejected as key functions |
| `mod` | ✅ supported | Returns modulo | BUG GAP-S138: non-finite operands return NaN instead of matching Clojure/JVM behavior |
| `name` | ✅ supported | Returns name string of symbol/keyword | DIV-19: quoted symbols are not supported as runtime values. BUG GAP-S129: character literals return strings instead of raising |
| `namespace` | ❌ not_relevant | Returns namespace of symbol/keyword | relies on namespace support |
| `nat-int?` | ✅ supported | Returns true if non-negative integer | DIV-37: arbitrary-precision PTC integers have no distinct JVM int/long width |
| `neg-int?` | ✅ supported | Returns true if negative integer | DIV-37: arbitrary-precision PTC integers have no distinct JVM int/long width |
| `neg?` | ✅ supported | Returns true if number negative | DIV-31: returns false for nil/non-numeric inputs instead of raising |
| `newline` | ❌ not_relevant | Writes newline to output | relies on I/O |
| `next` | ✅ supported | Returns seq after first item | DIV-29: direct map input raises; use seq/entries/keys/vals for ordered map views. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `nfirst` | ✅ supported | Next of first item | nil input returns nil, matching Clojure |
| `nil?` | ✅ supported | Returns true if nil |  |
| `nnext` | ✅ supported | Next of next item | nil input returns nil, matching Clojure |
| `not` | ✅ supported | Logical complement |  |
| `not-any?` | ✅ supported | Returns true if pred false for all | BUG GAP-S71: map/vector callables are rejected in predicate position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `not-empty` | ✅ supported | Returns collection or nil if empty | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `not-every?` | ✅ supported | Returns true if pred false for some | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `not=` | ✅ supported | Returns true if not equal | DIV-32: numeric equality is type-independent. BUG GAP-S120: character literals compare equal to one-character strings |
| `nth` | ✅ supported | Returns item at index | DIV-26 for out-of-range signal values; DIV-36 for string grapheme indexing; nil input returns nil (2-arity) or the default (3-arity), matching Clojure; the 3-arity (nth coll idx not-found) returns the default for out-of-range/negative; BUG GAP-S10/GAP-S79. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `nthnext` | ✅ supported | Returns nth next | implemented as seq after nthrest. BUG GAP-S79: numeric count coercion rejects floats Clojure accepts. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `nthrest` | ✅ supported | Returns rest after nth item | implemented as drop alias with Clojure argument order. BUG GAP-S79: numeric count coercion rejects floats Clojure accepts. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `num` | ❌ not_relevant | Coerces to number | JVM Number coercion; parse-long/parse-double cover string parsing |
| `number?` | ✅ supported | Returns true if number |  |
| `numerator` | ❌ not_relevant | Returns numerator of ratio | ratio values are not supported |
| `object-array` | ❌ not_relevant | Creates object Java array | relies on Java interop and host arrays |
| `odd?` | ✅ supported | Returns true if number odd | DIV-31: numeric predicates return false for non-numeric inputs |
| `or` | ✅ supported | Short-circuit logical OR |  |
| `parents` | ❌ not_relevant | Returns immediate parents of tag | metadata/hierarchy manipulation not supported in PTC-Lisp |
| `parse-boolean` | ✅ supported | Parses string to boolean | returns true, false, or nil |
| `parse-double` | ✅ supported | Parses string to double | BUG GAP-S61: surrounding whitespace and Java decimal spellings return nil instead of parsing |
| `parse-long` | ✅ supported | Parses string to long |  |
| `parse-uuid` | ❌ not_relevant | Parses string to UUID | no UUID runtime type; keep UUIDs as strings |
| `partial` | ✅ supported | Fixes supplied arguments to function | BUG GAP-S71: map/set/vector callables are rejected in function position |
| `partition` | ✅ supported | Partitions items into groups of n | BUG GAP-S31: nil padding collection currently raises instead of acting empty. BUG GAP-S53: negative partition size raises instead of returning an empty seq. BUG GAP-S79: numeric size/step coercion rejects floats Clojure accepts. |
| `partition-all` | ✅ supported | Partitions without dropping partial group | BUG GAP-S79: numeric size/step coercion rejects floats Clojure accepts. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `partition-by` | ✅ supported | Partitions by change in function value | BUG GAP-S71: map/vector callables are rejected in function position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `pcalls` | ✅ supported | Parallel calls to zero-arity functions |  |
| `peek` | ✅ supported | Returns first/last without removing | DIV-25 for list alias behavior |
| `persistent!` | ❌ not_relevant | Converts transient to persistent | transients are unsupported |
| `pmap` | ✅ supported | Parallel map over one or more collections | Matches map's finite seqable contract: nil collections, string collections, and multiple collections (zip-truncate to shortest) are supported while keeping bounded parallel limits |
| `pop` | ✅ supported | Returns collection without first/last | DIV-25 for list alias behavior; DIV-26 for empty collection signal value |
| `pop!` | ❌ not_relevant | Removes from transient collection | transients are unsupported |
| `pos-int?` | ✅ supported | Returns true if positive integer | DIV-37: arbitrary-precision PTC integers have no distinct JVM int/long width |
| `pos?` | ✅ supported | Returns true if number positive | DIV-31: returns false for nil/non-numeric inputs instead of raising |
| `pr` | ❌ not_relevant | Prints value in readable form | I/O operation |
| `pr-str` | ✅ supported | Returns readable string of value | DIV-39: collection rendering is deterministic, key-sorted for maps, and space-separated. BUG GAP-S126: character literals print as strings instead of character syntax |
| `prefer-method` | ❌ not_relevant | Prefers multimethod implementation | multimethods are unsupported |
| `prefers` | ❌ not_relevant | Returns multimethod preferences | multimethods are unsupported |
| `print` | ❌ not_relevant | Prints value without quoting | I/O operation |
| `print-str` | ❌ not_relevant | Returns printed string of value | relies on printing logic/I/O |
| `printf` | ❌ not_relevant | Prints formatted output | performs stdout I/O |
| `println` | ✅ supported | Prints with newline |  |
| `promise` | ❌ not_relevant | Creates promise | concurrency primitive |
| `proxy` | ❌ not_relevant | Creates proxy implementing interfaces | Java interop |
| `push-thread-bindings` | ❌ not_relevant | Installs thread-local bindings | thread-local mutability/state |
| `qualified-ident?` | ❌ not_relevant | Returns true if ident has namespace | namespaced identifiers are not supported as runtime values |
| `qualified-keyword?` | ❌ not_relevant | Returns true if keyword has namespace | namespaced keywords are not supported |
| `qualified-symbol?` | ❌ not_relevant | Returns true if symbol has namespace | symbols are not supported as runtime values |
| `quot` | ✅ supported | Returns integer division quotient | DIV-37: uses PTC-Lisp arbitrary-precision integers instead of JVM Long/MIN_VALUE overflow. BUG GAP-S138: non-finite operands return NaN instead of matching Clojure/JVM behavior |
| `quote` | ❌ not_relevant | Returns form unevaluated | quote syntax is intentionally unsupported; use vectors and data literals directly |
| `rand` | ❌ not_relevant | Returns random float 0-1 | non-deterministic randomness contradicts sandbox determinism |
| `rand-int` | ❌ not_relevant | Returns random int less than arg | relies on non-deterministic side effects/state |
| `rand-nth` | ❌ not_relevant | Returns random item from seq | relies on non-deterministic side effects/state |
| `random-sample` | ❌ not_relevant | Returns random sample of items | relies on non-deterministic side effects/state |
| `random-uuid` | ❌ not_relevant | Returns random UUID | relies on non-deterministic side effects |
| `range` | ✅ supported | Returns sequence of numbers |  |
| `ratio?` | ✅ supported | Returns true if ratio | always false; ratio literals are unsupported, see DIV-20 |
| `rational?` | ✅ supported | Returns true if rational number |  |
| `rationalize` | ❌ not_relevant | Coerces to ratio | ratio values are not supported |
| `re-find` | ✅ supported | Returns first regex match | BUG GAP-S92: optional unmatched capture groups are dropped instead of returned as nil slots. BUG GAP-S131: character inputs are accepted instead of raising |
| `re-groups` | ❌ not_relevant | Returns regex match groups | capture groups are returned directly by re-find, re-matches, and re-seq |
| `re-matcher` | ❌ not_relevant | Returns matcher for pattern | returns an object maintaining mutable state/matcher position |
| `re-matches` | ✅ supported | Returns full regex match or nil | BUG GAP-S92: optional unmatched capture groups are dropped instead of returned as nil slots. BUG GAP-S131: character inputs are accepted instead of raising |
| `re-pattern` | ✅ supported | Returns compiled regex pattern | BUG GAP-S66: existing regex patterns are rejected instead of returned. BUG GAP-S131: character patterns are accepted instead of raising |
| `re-seq` | ✅ supported | Returns seq of regex matches | BUG GAP-S82: no-match returns [] instead of nil. BUG GAP-S92: optional unmatched capture groups are dropped instead of returned as nil slots. BUG GAP-S131: character inputs are accepted instead of raising |
| `read` | ❌ not_relevant | Reads next form from reader | implies I/O and interaction with reader contexts |
| `read-line` | ❌ not_relevant | Reads line from input | I/O operation |
| `read-string` | ❌ not_relevant | Reads form from string | invokes reader/eval capabilities not supported in sandbox |
| `realized?` | ❌ not_relevant | Returns true if delay/future complete | relies on concurrency/lazy primitives not supported |
| `record?` | ❌ not_relevant | Returns true if record | relies on class/type system not supported |
| `recur` | ✅ supported | Rebinds loop vars and jumps to loop start |  |
| `reduce` | ✅ supported | Reduces collection with function | BUG GAP-S21: empty/nil input without init returns nil instead of calling the reducing function's zero-arity identity. BUG GAP-S71: map callables are rejected in function position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `reduce-kv` | ✅ supported | Reduces map with key-value function | BUG GAP-S59: vector input currently raises instead of reducing indexes and values |
| `reduced` | 🔲 candidate | Wraps value indicating reduction complete | pure control flow mechanism for reduction interruption |
| `reduced?` | 🔲 candidate | Returns true if wrapped in reduced | pure predicate for checking reduction status |
| `reductions` | ❌ not_relevant | Returns intermediate reduction results | returns a lazy sequence |
| `ref` | ❌ not_relevant | Creates STM reference | mutable state/concurrency primitive |
| `ref-set` | ❌ not_relevant | Sets ref value in transaction | mutable state/concurrency primitive |
| `reify` | ❌ not_relevant | Creates instance implementing protocols | relies on protocols and class generation |
| `rem` | ✅ supported | Returns remainder of division | BUG GAP-S138: non-finite operands return NaN instead of matching Clojure/JVM behavior |
| `remove` | ✅ supported | Returns items where predicate false | BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `remove-all-methods` | ❌ not_relevant | Removes all multimethod impls | relies on multimethods |
| `remove-method` | ❌ not_relevant | Removes multimethod impl | relies on multimethods |
| `remove-ns` | ❌ not_relevant | Removes namespace | relies on namespaces |
| `remove-tap` | ❌ not_relevant | Removes function from tap set | relies on global mutable state/taps |
| `remove-watch` | ❌ not_relevant | Removes watch from reference | relies on mutable state references |
| `repeat` | ❌ not_relevant | Returns infinite seq repeating value | returns lazy sequences |
| `repeatedly` | ❌ not_relevant | Returns seq calling function repeatedly | returns lazy sequences |
| `replace` | ✅ supported | Replaces values by map mapping | Arity-2 clojure.core seq replace (smap lookup over any seqable coll); arity-3 is the clojure.string/replace alias. 1-arity transducer form unsupported. Namespace collapse: (clojure.string/replace smap coll) runs the seq form instead of raising on arity. |
| `require` | ❌ not_relevant | Requires namespace | relies on namespace/load system |
| `requiring-resolve` | ❌ not_relevant | Requires ns and resolves symbol | relies on namespace/load system |
| `reset!` | ❌ not_relevant | Sets atom value | mutable state (atoms) |
| `reset-meta!` | ❌ not_relevant | Sets metadata | metadata manipulation |
| `reset-vals!` | ❌ not_relevant | Sets atom, returns [old new] | mutable state (atoms) |
| `resolve` | ❌ not_relevant | Resolves symbol in namespace | namespace/symbol resolution |
| `rest` | ✅ supported | Returns seq after first item | DIV-29: direct map input raises; use seq/entries/keys/vals for ordered map views. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `restart-agent` | ❌ not_relevant | Restarts failed agent | concurrency primitives (agents) |
| `reverse` | ✅ supported | Reverses order of items | DIV-29: direct map input raises; use seq/entries/keys/vals for ordered map views. BUG GAP-S20: nil input currently raises instead of returning an empty seq |
| `reversible?` | ✅ supported | Returns true if collection reversible | BUG GAP-S70: strings currently return true but Clojure returns false |
| `rseq` | ❌ not_relevant | Returns reverse seq of sorted collection | relies on lazy/sorted sequence implementation details |
| `rsubseq` | ❌ not_relevant | Returns reverse subseq of sorted coll | relies on lazy/sorted sequence implementation details |
| `run!` | ❌ not_relevant | Runs side effects, returns nil | relies on side effects |
| `satisfies?` | ❌ not_relevant | Returns true if type satisfies protocol | protocol/type system feature |
| `second` | ✅ supported | Returns second item | DIV-29: direct map input raises; use seq/entries/keys/vals for ordered map views. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `select-keys` | ✅ supported | Returns map with only specified keys | nil keyseq returns {} (matches Clojure). DIV-46: a string keyseq seqs to one-character strings that flex-match keyword keys, returning a populated map where Clojure returns {}. BUG GAP-S43: vector inputs currently raise instead of selecting indexes |
| `send` | ❌ not_relevant | Dispatches action to agent | relies on agent mutable state |
| `send-off` | ❌ not_relevant | Dispatches blocking action to agent | relies on agent mutable state |
| `send-via` | ❌ not_relevant | Sends action via executor to agent | relies on agent mutable state |
| `seq` | ✅ supported | Returns sequence or nil if empty | DIV-38: map views are sorted by key instead of preserving Clojure map iteration order. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `seq?` | ✅ supported | Returns true if value is sequence | BUG GAP-S84: vectors currently return true instead of false |
| `seqable?` | ✅ supported | Returns true if implements Seqable | BUG GAP-S125: character literals return true instead of false |
| `sequence` | ❌ not_relevant | Returns seq applying transducer | relies on lazy sequences |
| `sequential?` | ✅ supported | Returns true if sequential |  |
| `set` | ✅ supported | Creates set from items | BUG GAP-S30: nil and string inputs currently raise instead of producing sets |
| `set!` | ❌ not_relevant | Sets thread-local var value | relies on mutable state |
| `set?` | ✅ supported | Returns true if set |  |
| `short` | ❌ not_relevant | Coerces to short | JVM primitive width coercion |
| `short-array` | ❌ not_relevant | Creates short Java array | relies on Java array instantiation |
| `shorts` | ❌ not_relevant | Casts to short array | relies on Java array interaction |
| `shuffle` | ❌ not_relevant | Returns items in random order | relies on non-deterministic side effects (randomness) |
| `shutdown-agents` | ❌ not_relevant | Shuts down agent thread pool | manages thread pools which is unsupported |
| `simple-ident?` | ❌ not_relevant | Returns true if ident has no namespace | PTC-Lisp has keywords but no first-class symbol or namespaced identifier values |
| `simple-keyword?` | ❌ not_relevant | Returns true if keyword has no ns | namespaced keywords are not supported |
| `simple-symbol?` | ❌ not_relevant | Returns true if symbol has no ns | symbols are not supported as runtime values |
| `slurp` | ❌ not_relevant | Reads entire contents of file/URL | involves file/network I/O |
| `some` | ✅ supported | Returns first truthy result or nil | BUG GAP-S71: map/vector callables are rejected in function position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `some->` | ✅ supported | Threads through forms while non-nil | GAP-S128 fixed: nil thread targets raise once reached |
| `some->>` | ✅ supported | Threads as last arg while non-nil | GAP-S128 fixed: nil thread targets raise once reached |
| `some-fn` | ✅ supported | Returns pred true if any fn truthy | BUG GAP-S71: map/set/vector callables are rejected in predicate position |
| `some?` | ✅ supported | Returns true if not nil |  |
| `sort` | ✅ supported | Returns sorted sequence | DIV-30: uses PTC's recoverable total term ordering for nil and mixed values; BUG GAP-S20: nil input currently raises instead of returning an empty seq; BUG GAP-S46: nil comparator currently raises instead of using default compare; BUG GAP-S107: boolean comparator functions are not honored with Clojure ordering semantics |
| `sort-by` | ✅ supported | Returns seq sorted by function result | DIV-30: uses PTC's recoverable total term ordering for nil and mixed values; BUG GAP-S71: map/vector callables are rejected as key functions; BUG GAP-S107: boolean comparator functions are not honored with Clojure ordering semantics |
| `sorted-map` | 🔲 candidate | Creates sorted map from pairs | pure collection construction |
| `sorted-map-by` | 🔲 candidate | Creates sorted map with comparator | pure collection construction with custom comparator |
| `sorted-set` | 🔲 candidate | Creates sorted set from items | pure collection construction |
| `sorted-set-by` | 🔲 candidate | Creates sorted set with comparator | pure collection construction with custom comparator |
| `sorted?` | ✅ supported | Returns true if collection sorted |  |
| `spit` | ❌ not_relevant | Writes content to file | file I/O |
| `split-at` | ✅ supported | Splits seq at index | BUG GAP-S79: numeric count coercion rejects floats Clojure accepts. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `split-with` | ✅ supported | Splits seq by predicate | DIV-36: string sequence predicates receive one-character strings. BUG GAP-S71: map/vector callables are rejected in predicate position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `str` | ✅ supported | Converts to string | BUG GAP-S93: regex patterns render as internal tuples instead of source pattern text |
| `string?` | ✅ supported | Returns true if string | BUG GAP-S133: character literals return true instead of false |
| `struct` | ❌ not_relevant | Creates structure instance | legacy structure system, discouraged/deprecated |
| `struct-map` | ❌ not_relevant | Creates structure map from basis | legacy structure system, discouraged/deprecated |
| `subs` | ✅ supported | Returns substring | DIV-22: returns signal values instead of raising on out-of-range indices; DIV-36: string indexes use Unicode graphemes; BUG GAP-S79: numeric index coercion rejects floats Clojure accepts |
| `subseq` | 🔲 candidate | Returns subseq of sorted collection | pure operation on sorted collections |
| `subvec` | ✅ supported | Returns subvector | DIV-26: clamps out-of-range indices instead of raising. BUG GAP-S79: numeric index coercion rejects floats Clojure accepts |
| `supers` | ❌ not_relevant | Returns all ancestors of class | relies on Java class hierarchy/interop |
| `swap!` | ❌ not_relevant | Updates atom with function | requires mutable state (atom) |
| `swap-vals!` | ❌ not_relevant | Updates atom, returns [old new] | requires mutable state (atom) |
| `symbol` | 🔲 candidate | Coerces to symbol | pure data coercion |
| `symbol?` | ✅ supported | Returns true if symbol |  |
| `take` | ✅ supported | Returns first n items | BUG GAP-S20: nil input currently raises instead of returning an empty seq; BUG GAP-S32: negative count returns a tail instead of an empty seq; BUG GAP-S79: numeric count coercion rejects floats Clojure accepts |
| `take-last` | ✅ supported | Returns last n items | nil input returns nil, matching Clojure. BUG GAP-S32: negative count returns an empty vector instead of nil |
| `take-nth` | ❌ not_relevant | Returns every nth item | returns a lazy sequence |
| `take-while` | ✅ supported | Takes items while predicate true | BUG GAP-S71: map/vector callables are rejected in predicate position. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `tap>` | ❌ not_relevant | Sends value to taps | side-effecting I/O mechanism |
| `test` | ❌ not_relevant | Runs tests for namespace | built-in testing framework/REPL tool |
| `throw` | ❌ not_relevant | Throws exception | exception handling |
| `time` | ❌ not_relevant | Evaluates and prints elapsed time | side-effecting I/O and timing |
| `to-array` | ❌ not_relevant | Converts to object array | Java interop for array creation |
| `to-array-2d` | ❌ not_relevant | Converts to 2D array | Java interop for array creation |
| `trampoline` | ❌ not_relevant | Mutual recursion without stack overflow | lazy/mutual-recursion utility outside PTC-Lisp's small evaluator surface |
| `transduce` | 🔲 candidate | Reduces with transducer | Pure data transformation utility |
| `transient` | ❌ not_relevant | Creates transient collection | Mutable state/transients are not supported |
| `tree-seq` | ✅ supported | Depth-first seq from root | BUG GAP-S77: string roots can recurse until heap limit |
| `true?` | ✅ supported | Returns true if value is true |  |
| `try` | ❌ not_relevant | Exception handling | Exception handling is not supported |
| `type` | ✅ supported | Returns type of value | DIV-28: returns stable PTC type keywords instead of host JVM classes |
| `unchecked-add` | ❌ not_relevant | Adds without overflow check | Java-specific math optimization |
| `unchecked-add-int` | ❌ not_relevant | Adds ints without overflow check | Java-specific math optimization |
| `unchecked-byte` | ❌ not_relevant | Casts to byte without check | Java-specific primitive casting |
| `unchecked-char` | ❌ not_relevant | Casts to char without check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-dec` | ❌ not_relevant | Decrements without overflow check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-dec-int` | ❌ not_relevant | Decrements int without check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-divide-int` | ❌ not_relevant | Divides ints without check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-double` | ❌ not_relevant | Casts to double without check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-float` | ❌ not_relevant | Casts to float without check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-inc` | ❌ not_relevant | Increments without overflow check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-inc-int` | ❌ not_relevant | Increments int without check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-int` | ❌ not_relevant | Casts to int without check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-long` | ❌ not_relevant | Casts to long without check | Relies on Java primitive casting/low-level JVM semantics |
| `unchecked-multiply` | ❌ not_relevant | Multiplies without overflow check | relies on JVM-specific primitive behavior/overflow semantics |
| `unchecked-multiply-int` | ❌ not_relevant | Multiplies ints without check | relies on JVM-specific primitive behavior/overflow semantics |
| `unchecked-negate` | ❌ not_relevant | Negates without overflow check | relies on JVM-specific primitive behavior/overflow semantics |
| `unchecked-negate-int` | ❌ not_relevant | Negates int without check | relies on JVM-specific primitive behavior/overflow semantics |
| `unchecked-remainder-int` | ❌ not_relevant | Remainder without check | relies on JVM-specific primitive behavior/overflow semantics |
| `unchecked-short` | ❌ not_relevant | Casts to short without check | relies on Java type casting/interop |
| `unchecked-subtract` | ❌ not_relevant | Subtracts without overflow check | relies on JVM-specific primitive behavior/overflow semantics |
| `unchecked-subtract-int` | ❌ not_relevant | Subtracts ints without check | relies on JVM-specific primitive behavior/overflow semantics |
| `underive` | ❌ not_relevant | Removes hierarchical relationship | requires global hierarchy/multimethod infrastructure |
| `unreduced` | 🔲 candidate | Unwraps from reduced | pure transformation used for handling reduced values in reductions |
| `unsigned-bit-shift-right` | ❌ not_relevant | Unsigned right shift | no defined meaning on BEAM — integers are arbitrary-precision two's-complement with no fixed width to zero-fill from |
| `update` | ✅ supported | Applies function to map value at key | BUG GAP-S19: nil map root currently raises instead of building a map. BUG GAP-S83: vector append at count index raises instead of following assoc semantics |
| `update-in` | ✅ supported | Applies function to nested map value | An empty or nil path updates the value at the nil key, matching Clojure's recursive update-in definition; BUG GAP-S83: vector append at count index raises instead of following assoc semantics |
| `update-keys` | ✅ supported | Applies function to map keys | BUG GAP-S24: nil map currently returns nil instead of an empty map. BUG GAP-S71: map/set/vector callables are rejected as key transforms. BUG GAP-S75: vector inputs are rejected |
| `update-proxy` | ❌ not_relevant | Updates proxy method implementations | relies on Java interop/proxy class system |
| `update-vals` | ✅ supported | Applies function to map values | BUG GAP-S24: nil map currently returns nil instead of an empty map. BUG GAP-S71: map/set/vector callables are rejected as value transforms. BUG GAP-S75: vector inputs are rejected |
| `val` | ✅ supported | Returns value of map entry | BUG GAP-S17: currently accepts plain vectors/list pairs as map entries |
| `vals` | ✅ supported | Returns map values | DIV-38: map views are sorted by key instead of preserving Clojure map iteration order |
| `var-get` | ❌ not_relevant | Gets value of var | relies on specific var/namespace system |
| `var-set` | ❌ not_relevant | Sets var in thread-local binding | relies on mutable thread-local bindings |
| `var?` | ❌ not_relevant | Returns true if var | relies on var data structure absent in PTC-Lisp |
| `vary-meta` | ❌ not_relevant | Returns value with transformed metadata | relies on metadata feature |
| `vec` | ✅ supported | Converts to vector | BUG GAP-S40: nil input currently returns nil instead of an empty vector. BUG GAP-S130: character literals are treated as one-character strings instead of raising |
| `vector` | ✅ supported | Creates vector from items |  |
| `vector?` | ✅ supported | Returns true if vector | DIV-25 for list alias behavior |
| `volatile!` | ❌ not_relevant | Creates volatile with initial value | relies on mutable state |
| `volatile?` | ❌ not_relevant | Returns true if volatile | relies on mutable state |
| `vreset!` | ❌ not_relevant | Sets volatile value | relies on mutable state |
| `vswap!` | ❌ not_relevant | Updates volatile with function | involves mutable state (volatiles) |
| `when` | ✅ supported | Evaluates body if test true | Bodyless form returns nil, matching Clojure |
| `when-first` | ✅ supported | Evaluates body if seq non-empty | BUG GAP-S145: extra binding-vector forms are rejected instead of ignored |
| `when-let` | ✅ supported | Binds if truthy, evaluates body | DIV-14: destructuring bindings are intentionally unsupported. BUG GAP-S145: extra binding-vector forms are rejected instead of ignored |
| `when-not` | ✅ supported | Evaluates body if test false | Bodyless form returns nil, matching Clojure |
| `when-some` | ✅ supported | Binds if not nil, evaluates body | DIV-14: destructuring bindings are intentionally unsupported. BUG GAP-S145: extra binding-vector forms are rejected instead of ignored |
| `while` | ❌ not_relevant | Repeats body while test true | imperative looping construct typically relying on side effects |
| `with-bindings` | ❌ not_relevant | Executes body with thread-local bindings | relies on thread-local state which is not supported in the BEAM model for PTC-Lisp |
| `with-in-str` | ❌ not_relevant | Evaluates body with string as input | relies on I/O streams |
| `with-local-vars` | ❌ not_relevant | Evaluates body with local var bindings | requires mutable local vars |
| `with-meta` | ❌ not_relevant | Returns value with new metadata | metadata is not supported |
| `with-open` | ❌ not_relevant | Opens resources, closes on exit | relies on I/O and resource management |
| `with-out-str` | ❌ not_relevant | Captures output to string | relies on capturing side-effecting I/O |
| `with-precision` | ❌ not_relevant | Sets decimal precision for body | relies on specific BigDecimal support and dynamic binding context not present in PTC-Lisp |
| `with-redefs` | ❌ not_relevant | Redefines vars for body duration | modifies global var bindings, which is not supported in a functional, immutable sandbox |
| `xml-seq` | ❌ not_relevant | Lazy seq of XML elements | relies on lazy sequences and I/O-related parsing |
| `zero?` | ✅ supported | Returns true if number is zero | DIV-31: returns false for nil/non-numeric inputs instead of raising |
| `zipmap` | ✅ supported | Creates map from keys and values seqs | BUG GAP-S130: character literals are treated as one-character strings instead of raising |