How does Atlas handle renaming a Haskell function used in multiple modules?

Atlas uses `lsp findReferences` to get an authoritative list of all usages across your Haskell modules, then applies `edit replaceAll` to update every instance, ensuring consistency throughout your `cabal` project.

Can Atlas rename a Haskell typeclass or data constructor?

Yes, Atlas can rename any Haskell symbol, including typeclasses, data constructors, and record fields, by leveraging the `lsp` tool's understanding of your GHC type system.

What if the old symbol name appears in a comment or string literal in Haskell?

Atlas runs `grep` for the old name specifically to catch occurrences in comments, string literals, and documentation, which the `lsp` tool might miss, ensuring a complete rename in your Haskell project.

How does Atlas prevent accidental renames of unrelated Haskell code?

Atlas's `edit` tool refuses ambiguous single replacements. For a full rename, `replaceAll` is used on the precise set of references identified by `lsp` and `grep`, and all changes are presented as a unified diff for your approval.

Does Atlas integrate with `cabal` or `stack` for Haskell projects?

Atlas integrates direct with Haskell projects using either `.cabal` files or `stack.yaml`. It reads your module hierarchy, `default-extensions`, and `build-depends` to understand your project context.

How does Atlas ensure the refactored Haskell code still compiles and passes tests?

After renaming, Atlas uses the `bash` tool to run `cabal build` to catch GHC type errors and `cabal test` to execute your `hspec` suite, iterating on diffs until the Haskell code typechecks and tests pass.

Can I review the changes Atlas makes to my Haskell files before they are saved?

Absolutely. Atlas computes a unified diff for every file edit and surfaces it for your explicit approval. You can review all proposed changes to your Haskell codebase before they are written.

Rename a symbol across your Haskell repo in 2026 with Atlas

Atlas renames Haskell symbols across your entire repository by leveraging `lsp` for precise type-aware references, `grep` for non-code occurrences, and `edit` for safe, mechanical replacements, ensuring your `cabal` project remains consistent and type-checks. This process is designed for Haskell developers in 2026 seeking robust refactoring.

How Atlas finds all references for a Haskell symbol

Atlas precisely identifies all references for a Haskell symbol, including functions, classes, or constants, by first querying the language server via `lsp`'s `findReferences` tool. This ensures 100% accuracy for type-system-visible usages in your `cabal` project, even in 2026, before expanding the search.

To rename a Haskell symbol comprehensively, Atlas employs a two-pronged approach. First, it utilizes the `lsp` tool's `findReferences` operation. This connects directly to your Haskell language server, which has a deep understanding of your project's type signatures, typeclass instances, and module hierarchy. This step is crucial for accurately identifying all code-level usages of a function, type, or constant, ensuring that even complex, type-driven references are caught. For instance, if you rename a function `myOldFunction` defined in `src/MyModule.hs`, `lsp` will find all calls to it, including those in `test/Spec.hs` or other application modules, respecting `build-depends` and `default-extensions` defined in your `.cabal` file. Second, Atlas runs `grep` for the old symbol name. This is vital for catching occurrences that the language server might not see, such as comments, string literals, documentation blocks, or even configuration files like `stack.yaml` or `.cabal` files where the symbol might be mentioned. For example, a comment like `-- This uses myOldFunction` or a string `"Error in myOldFunction"` would be missed by `lsp` but caught by `grep`. This hybrid approach ensures that the rename is truly exhaustive, covering both the compiler's view and human-readable contexts within your Haskell repository.

How Atlas safely renames Haskell symbols across files

After gathering all references, Atlas performs the mechanical rename using its `edit` tool with `replaceAll`. This ensures every identified occurrence of the old symbol name is updated across your Haskell codebase, with a 1-to-1 replacement guarantee per file, preventing ambiguous matches and ensuring a clean refactor.

Once Atlas has compiled a complete list of references using `lsp` and `grep`, it proceeds with the actual renaming using the `edit` tool. The `edit` tool is designed for mechanical, precise text replacements. For a full symbol rename, Atlas uses `replaceAll`, which ensures that every identified instance of the old name is replaced with the new name within the specified files. A key safety feature of `edit` is its refusal of ambiguous single replacements; if you were to attempt a single `edit` operation and it found multiple matches for `oldString` in a file, it would throw an error unless `replaceAll` was explicitly used or more context was provided. This prevents unintended corruption of your Haskell source files. Atlas drafts a plan in a read-only plan agent first, detailing which files will be modified and how. This plan is presented to you for approval before any changes are committed. The `edit` tool also leverages Atlas's ability to snapshot file changes as `git` patches, meaning every edit can be easily diffed, reviewed, and rolled back if necessary. This robust mechanism ensures that renaming a Haskell function like `calculateTotal` to `computeAggregate` across dozens of `.hs` files is performed with precision and full auditability.

Verifying Haskell symbol renames with `cabal` and `hspec`

After Atlas applies the renames, it's crucial to verify the changes. Atlas facilitates this by running `cabal build` to catch any GHC type errors and executing your `hspec` test suite to confirm functional correctness, ensuring a robust refactor in 2026 and preventing regressions.

A successful refactor in Haskell isn't just about changing names; it's about ensuring the code still compiles and behaves as expected. Atlas integrates directly with your Haskell toolchain to provide this verification. Using the `bash` tool, Atlas will first execute `cabal build`. This command invokes GHC, the Glasgow Haskell Compiler, which will rigorously check the entire project for type errors, missing imports, or other compilation issues introduced by the rename. If `cabal build` fails, Atlas can then iterate on the diff, suggesting further changes until the project typechecks cleanly. Following a successful build, Atlas will run your test suite by executing `bash -c "cabal test"`. If your project uses `hspec` for testing, this will run all your specifications, confirming that the renamed symbol's functionality remains intact and no regressions have been introduced. Finally, Atlas performs one more `grep` for the old symbol name across the entire repository. This last check serves as a definitive proof that zero remaining hits of the old name exist, ensuring a truly complete refactor. Before you approve the final commit, Atlas can also apply `fourmolu` to the changed modules, ensuring your Haskell code adheres to your project's formatting standards.

Atlas's approval workflow for Haskell refactoring

Atlas prioritizes safety and developer control throughout the refactoring process. Every Atlas tool call is permission-gated, and it computes a unified diff for every file edit, presenting it for your explicit approval before any changes are written to your Haskell project, offering 100% transparency.

The entire refactoring workflow with Atlas is built around transparency and developer approval. Before any Atlas tool, such as `lsp`, `grep`, `edit`, or `bash`, is executed, its call is permission-gated against allow, ask, and deny rules. This means you are always in control, deciding whether Atlas can proceed with a specific action. When Atlas proposes changes to your Haskell files, it doesn't just make them silently. Instead, it computes a unified diff for every file edit, clearly showing what has been added, removed, or changed. This comprehensive diff is surfaced for your explicit approval. You can review every line of code Atlas intends to modify, ensuring that the rename of a Haskell function like `processData` to `handleInput` is exactly as you expect. Atlas also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, streamlining the integration of approved changes into your version control system. This robust approval mechanism, combined with the ability to roll back changes via `git` patches, provides a secure and confident way to perform complex refactors in your Haskell codebase.

Step by step

01Run `atlas` in your Haskell project directory, ensuring a `.cabal` file or `stack.yaml` is present.
02Ask Atlas to find all references for the target Haskell symbol using `lsp findReferences` and `grep` for non-code occurrences.
03Approve Atlas's read-only plan to apply mechanical renames with `edit replaceAll` across your Haskell modules.
04Instruct Atlas to run `bash -c "cabal build"` to check for GHC type errors after the rename.
05Have Atlas execute `bash -c "cabal test"` to run your `hspec` test suite and confirm functional correctness.
06Approve Atlas's proposed `fourmolu` formatting changes to any modified Haskell files.
07Review the unified diffs for all changes and approve Atlas to stage and commit the refactored Haskell code.
08Perform a final `grep` for the old symbol name across the repository to confirm zero remaining hits.

Frequently asked questions

How does Atlas handle renaming a Haskell function used in multiple modules?: Atlas uses `lsp findReferences` to get an authoritative list of all usages across your Haskell modules, then applies `edit replaceAll` to update every instance, ensuring consistency throughout your `cabal` project.
Can Atlas rename a Haskell typeclass or data constructor?: Yes, Atlas can rename any Haskell symbol, including typeclasses, data constructors, and record fields, by leveraging the `lsp` tool's understanding of your GHC type system.
What if the old symbol name appears in a comment or string literal in Haskell?: Atlas runs `grep` for the old name specifically to catch occurrences in comments, string literals, and documentation, which the `lsp` tool might miss, ensuring a complete rename in your Haskell project.
How does Atlas prevent accidental renames of unrelated Haskell code?: Atlas's `edit` tool refuses ambiguous single replacements. For a full rename, `replaceAll` is used on the precise set of references identified by `lsp` and `grep`, and all changes are presented as a unified diff for your approval.
Does Atlas integrate with `cabal` or `stack` for Haskell projects?: Atlas integrates direct with Haskell projects using either `.cabal` files or `stack.yaml`. It reads your module hierarchy, `default-extensions`, and `build-depends` to understand your project context.
How does Atlas ensure the refactored Haskell code still compiles and passes tests?: After renaming, Atlas uses the `bash` tool to run `cabal build` to catch GHC type errors and `cabal test` to execute your `hspec` suite, iterating on diffs until the Haskell code typechecks and tests pass.
Can I review the changes Atlas makes to my Haskell files before they are saved?: Absolutely. Atlas computes a unified diff for every file edit and surfaces it for your explicit approval. You can review all proposed changes to your Haskell codebase before they are written.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Rename a Symbol Across the Repo with Atlas in 2026

How to rename a symbol across a repo with Atlas in 2026: findReferences gets the true reference set, grep catches strings and docs, and edit refuses ambiguous matches.

Atlas for Haskell in 2026

Atlas is a terminal-native AI coding agent for Haskell in 2026. Run it in a project with a .cabal file or a stack.yaml, let cabal build drive it, and review the diff.

Audit a Haskell Repo with Parallel Subagents in 2026

Sweep your Haskell repository for problems in 2026 using Atlas's parallel subagents. Leverage `cabal`, `hspec`, and `fourmolu` to audit code without blowing your context window.

Run Atlas Headless in CI for Haskell Projects in 2026

Automate Haskell development in CI with Atlas. Run Atlas headless to fix `cabal` build errors, add `hspec` tests, and apply `fourmolu` formatting, getting machine-readable output for your pipelines.

Plan a multi-file change before editing in Haskell with Atlas in 2026

In 2026, Haskell developers use Atlas to design complex, multi-file changes and get them reviewed before writing a single line of code. Leverage cabal, hspec, and fourmolu for verified planning.

Document a Module with a README in Haskell with Atlas in 2026

In 2026, Atlas helps Haskell developers generate accurate README documentation directly from source code. Leverage `cabal` and `fourmolu` to ensure your docs reflect current module behavior.

Automate GitHub Issue and Pull Request Triage in Haskell with Atlas in 2026

In 2026, Haskell developers can automate GitHub issue and pull request triage using Atlas. Configure Atlas to respond safely, leveraging `cabal` and `fourmolu` for verified code changes.

Onboard to an Unfamiliar Haskell Codebase with Atlas in 2026

Quickly build a working mental model of any Haskell repository in 2026 using Atlas. Leverage `cabal`, `hspec`, and `fourmolu` for efficient, safe onboarding.

Browse this resource hub