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

Core, validated AST for PTC-Lisp.

This module defines the type specifications for the intermediate
representation that the analyzer produces. The interpreter evaluates
CoreAST to produce results.

## Pipeline

```
source → Parser → RawAST → Analyze → CoreAST → Eval → result
```

# `binding`

```elixir
@type binding() :: {:binding, pattern(), t()}
```

# `fn_params`

```elixir
@type fn_params() :: [pattern()] | {:variadic, [pattern()], pattern()}
```

# `literal`

```elixir
@type literal() ::
  nil
  | boolean()
  | number()
  | {:string, String.t()}
  | {:keyword, name()}
  | {:symbol_ref, String.t()}
  | {:repl_discovery, atom(), [t()]}
```

# `name`

```elixir
@type name() :: atom() | String.t()
```

# `pattern`

```elixir
@type pattern() ::
  {:var, name()}
  | {:destructure, {:keys, [name()], keyword()}}
  | {:destructure, {:map, [name()], [{pattern(), term()}], keyword()}}
  | {:destructure, {:as, name(), pattern()}}
  | {:destructure, {:seq, [pattern()]}}
  | {:destructure, {:seq_rest, [pattern()], pattern()}}
```

# `t`

```elixir
@type t() ::
  literal()
  | {:vector, [t()]}
  | {:map, [{t(), t()}]}
  | {:set, [t()]}
  | {:var, name()}
  | {:data, name()}
  | {:call, t(), [t()]}
  | {:let, [binding()], t()}
  | {:if, t(), t(), t()}
  | {:fn, fn_params(), t()}
  | {:fn, name(), fn_params(), t()}
  | {:do, [t()]}
  | {:and, [t()]}
  | {:or, [t()]}
  | {:return, t()}
  | {:fail, t()}
  | {:task, String.t(), t()}
  | {:task_dynamic, t(), t()}
  | {:step_done, t(), t()}
  | {:task_reset, t()}
  | {:tool_call, name(), [t()]}
  | {:prelude_ref, String.t()}
  | {:prelude_call, String.t(), [t()]}
  | {:def, name(), t(), map()}
  | {:defonce, name(), t(), map()}
  | {:loop, [binding()], t()}
  | {:recur, [t()]}
```

---

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