# `PtcRunner.Lisp.Registry`
[🔗](https://github.com/andreasronge/ptc_runner/blob/main/lib/ptc_runner/lisp/registry.ex#L1)

Single source of truth for PTC-Lisp function metadata.

Loads `priv/functions.exs` (implemented + Java interop entries),
`priv/function_audit.exs` (Clojure/Java Math parity triage notes), and
`priv/java_compat_audit.exs` (curated Java compatibility targets) at
compile time via `@external_resource`. No runtime file I/O —
recompiles automatically when any source file changes.

The two files are split (#896) because their change cadence differs:
`functions.exs` is touched when the language definition evolves, while
`function_audit.exs` is touched when triaging Clojure/Java parity.
Keeping them separate keeps each file in a more manageable size range
and avoids recompiling dependents when only audit metadata changes.

## Usage

    Registry.doc("filter")
    #=> %{name: "filter", signatures: [...], ...}

    Registry.builtins_by_category(:string)
    #=> [:format, :name, :str, ...]

    Registry.find_doc("sort")
    #=> [%{name: "sort", ...}, %{name: "sort-by", ...}]

See also: `PtcRunner.Lisp.Env`, `PtcRunner.Lisp.Analyze`

# `builtins_by_category`

```elixir
@spec builtins_by_category(atom()) :: [atom()]
```

Returns env-dispatched builtin names for the given category.

## Examples

    iex> :join in PtcRunner.Lisp.Registry.builtins_by_category(:string)
    true

    iex> :set in PtcRunner.Lisp.Registry.builtins_by_category(:set)
    true

# `builtins_by_namespace`

```elixir
@spec builtins_by_namespace(atom()) :: [atom() | String.t()]
```

Returns env-dispatched builtin names that are supported for the given
compatibility namespace.

Unlike `builtins_by_category/1`, this represents namespace membership rather
than presentation grouping. For example, `clojure.core/str` is valid even
though `str` is displayed in the String Functions section.

# `category_name`

```elixir
@spec category_name(atom()) :: String.t()
```

Returns a human-readable name for a category.

## Examples

    iex> PtcRunner.Lisp.Registry.category_name(:string)
    "String"

    iex> PtcRunner.Lisp.Registry.category_name(:core)
    "Core"

# `clojure_core_audit`

```elixir
@spec clojure_core_audit() :: [map()]
```

Returns all clojure.core audit entries.

## Examples

    iex> entries = PtcRunner.Lisp.Registry.clojure_core_audit()
    iex> is_list(entries) and length(entries) > 400
    true

# `clojure_set_audit`

```elixir
@spec clojure_set_audit() :: [map()]
```

Returns all clojure.set audit entries.

## Examples

    iex> entries = PtcRunner.Lisp.Registry.clojure_set_audit()
    iex> is_list(entries) and length(entries) > 8
    true

# `clojure_string_audit`

```elixir
@spec clojure_string_audit() :: [map()]
```

Returns all clojure.string audit entries.

## Examples

    iex> entries = PtcRunner.Lisp.Registry.clojure_string_audit()
    iex> is_list(entries) and length(entries) > 15
    true

# `clojure_walk_audit`

```elixir
@spec clojure_walk_audit() :: [map()]
```

Returns all clojure.walk audit entries.

## Examples

    iex> entries = PtcRunner.Lisp.Registry.clojure_walk_audit()
    iex> is_list(entries) and length(entries) > 5
    true

# `doc`

```elixir
@spec doc(String.t()) :: map() | nil
```

Looks up documentation for a function by exact name.

Handles namespace-qualified names (e.g., `"LocalDate/parse"` → `"parse"`,
`"System/currentTimeMillis"` → `"currentTimeMillis"`,
`"java.time.Duration/between"` → `"Duration/between"`).

## Examples

    iex> entry = PtcRunner.Lisp.Registry.doc("filter")
    iex> entry.name
    "filter"

    iex> entry = PtcRunner.Lisp.Registry.doc("LocalDate/parse")
    iex> entry.name
    "parse"

    iex> entry = PtcRunner.Lisp.Registry.doc("java.time.Duration/between")
    iex> entry.name
    "Duration/between"

# `find_doc`

```elixir
@spec find_doc(String.t()) :: [map()]
```

Searches functions by name, description, or section pattern.

## Examples

    iex> results = PtcRunner.Lisp.Registry.find_doc("sort")
    iex> Enum.any?(results, & &1.name == "sort")
    true

    iex> results = PtcRunner.Lisp.Registry.find_doc("interop")
    iex> Enum.all?(results, & &1.section == "Interop")
    true

# `implemented`

```elixir
@spec implemented() :: [map()]
```

Returns all implemented function entries.

## Examples

    iex> entries = PtcRunner.Lisp.Registry.implemented()
    iex> is_list(entries) and length(entries) > 100
    true

# `java_compat_audit`

```elixir
@spec java_compat_audit(atom()) :: [map()]
```

Returns a curated Java compatibility audit by key.

# `java_compat_audit_keys`

```elixir
@spec java_compat_audit_keys() :: [atom()]
```

Returns the available curated Java compatibility audit keys.

# `java_interop`

```elixir
@spec java_interop() :: [map()]
```

Returns all Java interop entries.

## Examples

    iex> entries = PtcRunner.Lisp.Registry.java_interop()
    iex> is_list(entries) and length(entries) > 5
    true

# `java_math_audit`

```elixir
@spec java_math_audit() :: [map()]
```

Returns all java.lang.Math audit entries.

## Examples

    iex> entries = PtcRunner.Lisp.Registry.java_math_audit()
    iex> is_list(entries) and length(entries) > 30
    true

---

*Consult [api-reference.md](api-reference.md) for complete listing*