Add set formatting to formatter.ex (Phase 6 of #164)

[andreasronge]

Summary

Add set literal formatting support to the PTC-Lisp formatter, enabling {:set, [...]} AST nodes to be serialized as #{...} source code strings. This completes the set literal feature by enabling roundtrip verification (parse → format → parse) and debugging output for set expressions.

Context

Architecture reference: Set Literal Implementation Plan - Phase 7: Formatter
Dependencies: Phases 1-5 complete (parser, AST types, analyzer, evaluator, runtime)
Related issues: Part of epic #164

Current State

The formatter (lib/ptc_runner/lisp/formatter.ex) handles all AST node types except sets:

• {:vector, elems} → "[#{format_list(elems)}]" (line 27-29)
• {:map, pairs} → "{#{format_pairs(pairs)}}" (line 31-33)
• No {:set, elems} clause exists

Attempting to format a set AST will raise a FunctionClauseError.

Acceptance Criteria

• Formatter.format({:set, []}) returns "#{}" (empty set)
• Formatter.format({:set, [1, 2, 3]}) returns "#{1 2 3}"
• Nested sets format correctly: {:set, [{:set, [1]}]} → "#{#{1}}"
• Sets containing other types format correctly (keywords, strings, vectors, maps)
• Roundtrip test passes: parse set → format → parse → compare AST
• Existing formatter tests pass (no regressions)

Implementation

Files to modify:

• lib/ptc_runner/lisp/formatter.ex - Add format/1 clause for {:set, elems}
• test/ptc_runner/lisp/formatter_test.exs - Add set formatting tests

Pattern to follow (line 27-29):

def format({:vector, elems}) do
  "[#{format_list(elems)}]"
end

Implementation (add after map formatting, ~line 33):

def format({:set, elems}) do
  "\#{#{format_list(elems)}}"
end

Critical escaping note:
Elixir's string interpolation uses #{} syntax. The set delimiter # must be escaped:

• Use "\#{#{format_list(elems)}}" (escape the first #)
• The inner #{...} is Elixir interpolation, the outer \# becomes literal #

Test Plan

Unit tests to add in test/ptc_runner/lisp/formatter_test.exs:

describe "sets" do
  test "empty set" do
    # Use string concat to avoid Elixir interpolation issues
    assert Formatter.format({:set, []}) == "#" <> "{}"
  end

  test "set with elements" do
    assert Formatter.format({:set, [1, 2, 3]}) == "#" <> "{1 2 3}"
  end

  test "set with mixed types" do
    assert Formatter.format({:set, [1, {:keyword, :a}, {:symbol, :x}]}) ==
             "#" <> "{1 :a x}"
  end

  test "nested set" do
    assert Formatter.format({:set, [{:set, [1, 2]}]}) == "#" <> "{#" <> "{1 2}}"
  end
end

Roundtrip tests:

describe "roundtrip verification" do
  test "set roundtrip" do
    set_str = "#" <> "{1 2 3}"
    {:ok, ast} = Parser.parse(set_str)
    formatted = Formatter.format(ast)
    {:ok, reparsed} = Parser.parse(formatted)
    assert ast == reparsed
  end

  test "nested set roundtrip" do
    set_str = "#" <> "{#" <> "{1} [2 3]}"
    {:ok, ast} = Parser.parse(set_str)
    formatted = Formatter.format(ast)
    {:ok, reparsed} = Parser.parse(formatted)
    assert ast == reparsed
  end
end

Note: Tests use string concatenation ("#" <> "{}") to avoid Elixir's #{} interpolation, following the same pattern used in parser_test.exs.

Out of Scope

• Pretty-printing with indentation (all collections are single-line)
• MapSet runtime value formatting (formatter handles AST, not evaluated values)
• Configurable output styles

Documentation Updates

None - the formatter is an internal module with no public API documentation.

[andreasronge]

Issue Review: Add set formatting to formatter.ex (Phase 6 of #164)

Summary: Well-specified issue to add set literal formatting support to the PTC-Lisp formatter. This is Phase 6 of the set literal epic (#164), following completed phases 1-5.

Pre-Review Checks:

• Codebase health: Pass - All 1002 tests passing, 0 failures
• Higher-priority blockers: None - No open bugs, this is the next sequential phase
• Issue claims verified: Yes - Confirmed formatter.ex has no {:set, elems} clause (lines 1-57 reviewed)

Analysis:

1. Should This Be Done?: Yes - completes the set literal feature enabling roundtrip testing (parse → format → parse). Parser tests already use string concat pattern to test sets.

2. Simplifications: None needed - single function clause addition following established patterns.

3. Codebase Research:

   • Verified formatter.ex structure (57 lines, follows vector/map pattern)
   • Confirmed parser already handles sets (tests at lines 104-144 in parser_test.exs)
   • Formatter tests exist at test/ptc_runner/lisp/formatter_test.exs (240 lines)
   • No existing set tests in formatter_test.exs

4. Reuse Opportunities: Yes - format_list/1 helper already exists for formatting element lists.

5. Refactoring Needs: None - direct addition.

6. Edge Cases: Covered - empty set, nested sets, mixed types all specified in test plan.

7. Issue Scope: Appropriate - 2 files, ~5 lines of implementation + ~30 lines of tests.

8. Test Plan: Good - unit tests + roundtrip tests following testing-guidelines.md patterns.

9. Solution Outline: Excellent - complete implementation code provided with escaping notes.

Technical Issues Found:

• None

Changes Made to Issue Body:

• Fixed test examples to use string concatenation ("#" <> "{}") to avoid Elixir interpolation issues (following parser_test.exs pattern)
• Added note explaining why string concat is needed in tests
• Clarified escaping explanation in implementation section
• Minor formatting improvements

Recommended Labels:

• ready-for-implementation
• claude-approved
• enhancement (already present)

Verdict: Ready for implementation

[andreasronge]

@claude Please implement this issue.

Context:

• This is Phase 6 of the Set Literal epic (Set Literal Syntax (#{...}) for PTC-Lisp #164)
• Phases 1-5 are complete (parser, AST types, analyzer, evaluator, runtime)
• Sets are represented as MapSet at runtime

Key files to read:

• docs/ptc-lisp-set-literal-plan.md - Implementation spec with formatter section
• lib/ptc_runner/lisp/formatter.ex - Target file for changes
• test/ptc_runner/lisp/formatter_test.exs - Add tests here

Critical requirement:

• The # character must be escaped in the output since #{ starts a set literal

Run the full quality check when done: mix format --check-formatted && mix compile --warnings-as-errors && mix test

[andreasronge]

Implementation complete! Phase 6 (Formatter) has been successfully implemented.

Changes:

• Added format({:set, elems}) clause to lib/ptc_runner/lisp/formatter.ex
• Properly escapes the # character using string concatenation syntax to avoid Elixir interpolation
• Added 8 unit tests + 3 roundtrip tests to test/ptc_runner/lisp/formatter_test.exs

Quality Checks:
✅ Code formatting (mix format --check-formatted)
✅ Compilation (mix compile --warnings-as-errors)
✅ All 1010 tests passing
✅ Pre-commit checks passed

PR: #178