Para quien es esto

Quieres pausar codigo Haskell en IntelliJ IDEA Ultimate (la version de pago de JetBrains, la que usas para PHP/Java/Python), ver tus thunks expandirse en el panel de variables, y hacer step over en codigo perezoso. Esta guia te lleva del cero a tu primer breakpoint.

Si quieres entender POR QUE esto importa o leer el diario de batalla con todas las trampas, mira mi otro post: Hito doble: Haskell con debugger en Doom y en IntelliJ.

Aqui solo pasos. Resultado al final:

Requisitos

• IntelliJ IDEA Ultimate 2026.1 (o version reciente con soporte LSP4IJ).
• Un proyecto Haskell con flake.nix y cabal, con GHC 9.14+ y hdb ya instalados. Si todavia no los tienes, sigue primero los pasos 1-4 del howto Doom Emacs (los puntos sobre flake.nix, cabal install haskell-debugger, wrapper hdb-dap y hie.yaml son comunes).
• ~/.local/bin/hdb-dap en PATH, ejecutable, con el wrapper que entra en nix develop.

Paso 1: Instalar LSP4IJ

LSP4IJ es el plugin de Red Hat que añade soporte LSP/DAP user-defined en IntelliJ.

1. Settings → Plugins → Marketplace.
2. Buscar LSP4IJ.
3. Install. Restart IDE.

(Opcional pero muy recomendado: instalar tambien el plugin Haskell LSP de Rockofox. NO lo vamos a usar para HLS — porque HLS no soporta GHC 9.14 todavia — pero registra automaticamente el fileType "Haskell language file" que LSP4IJ necesita. Es free.)

Paso 2: Asegurar el fileType Haskell

LSP4IJ envia los breakpoints al adapter solo si IntelliJ reconoce .hs como un fileType. Hay dos vias:

Via A: Tienes el plugin Haskell LSP instalado

Listo, no haces nada. El plugin registra "Haskell language file" para *.hs y *.lhs. Comprueba abriendo un fichero .hs: el icono del tab debe ser una lambda, no texto plano. Si sale lambda, salta al paso 3.

Via B: Sin plugin, registrar el fileType a mano

Settings → Editor → File Types → boton "+" arriba para añadir. Rellena:

• Name: Haskell
• Description: Haskell source
• Line comment: --
• Block comment start: {-
• Block comment end: -}
• Marca Support paired braces, Support paired brackets, Support paired parens.
• Pulsa OK.

Selecciona "Haskell" en la lista. Abajo en "File name patterns", pulsa "" y añade *.hs. Pulsa "" otra vez y añade *.lhs. Apply.

(Si IntelliJ te avisa "This wildcard is already registered by 'Haskell language file' filetype", cancela tu fileType custom: ya tienes uno via plugin. Esa via es la A.)

Paso 3: Crear el Run/Debug DAP Configuration

3.1 Abrir el editor

Settings → Other Settings → Debug Adapter Protocol → boton "+" para añadir un template nuevo. Te ofrece varias pestañas: Server, Mappings, Configuration, Installer.

3.2 Server tab

• Name: Haskell hdb

• Environment variables: vacio

• Command:

  bash -c "cd $PROJECT_DIR$ && exec $USER_HOME$/.local/bin/hdb-dap server --port ${port}"
  

  Comillas dobles obligatorias. ${port} lo sustituye LSP4IJ por un puerto libre. $PROJECT_DIR$ y $USER_HOME$ son variables de IntelliJ portables.

• Connect to the server by waiting: marca el radio **"Log pattern before proceeding"** y pon: Running DAP server on

• Trace: off (cambia a verbose solo si necesitas debuggear).

3.3 Mappings tab

Activa el sub-tab **"File type"** y añade una entrada:

• File type: Haskell (el que registraste en el paso 2)
• Language Id: haskell

(Tambien puedes añadir un mapping en "File name patterns" con *.hs y *.lhs por si acaso, pero con el File type ya basta.)

3.4 Configuration tab

• Working directory: $PROJECT_DIR$

• File: la ruta absoluta al fichero que vas a debuggear, por ejemplo $PROJECT_DIR$/app/Debugging101.hs

• Debug Mode: Launch

• Use the configuration: dejalo vacio

• DAP parameters (JSON): pega esto y adapta entryFile a tu proyecto:

  {
    "type": "haskell-debugger",
    "name": "Debug Haskell file",
    "request": "launch",
    "projectRoot": "$PROJECT_DIR$",
    "entryFile": "$PROJECT_DIR$/app/Debugging101.hs",
    "entryPoint": "main",
    "entryArgs": [],
    "extraGhcArgs": [],
    "internalInterpreter": true,
    "cwd": "$PROJECT_DIR$"
  }

  $PROJECT_DIR$ se sustituye en runtime por la ruta del proyecto. Hace la config portable entre clones del repo.

3.5 Apply, OK

Cierra el dialogo entero. Te queda una Run/Debug Configuration nueva en la dropdown del IDE.

Paso 4: Persistir la config en el repo (recomendado)

Por defecto, la config se guarda en tu IntelliJ local. Para que cualquier persona que clone tu repo herede la misma config:

1. Abre la dropdown de Run/Debug Configurations → Edit Configurations.
2. Selecciona tu "Haskell hdb".
3. Marca el checkbox **"Store as project file"**.
4. Apply, OK.

IntelliJ guarda la config en .idea/runConfigurations/<nombre>.xml. Commitea ese fichero al repo:

cd ~/src/tu-proyecto-haskell
git add -f .idea/runConfigurations/Haskell-hdb.xml
git commit -m "feat(.idea): persistir DAP Configuration para hdb"

(-f si tu gitignore global excluye .idea/.)

Paso 5: Tu primer breakpoint

1. Abre tu fichero .hs en el editor.
2. Verifica que el icono del tab tiene la lambda Haskell, no texto plano. Si no, vuelve al paso 2.
3. Pon breakpoint clicando en el margen izquierdo. Sale circulo rojo.
4. MUY IMPORTANTE: pulsa el boton DEBUG (icono escarabajo verde 🐞), NO el boton Run (▶ triangulo verde). Si pulsas Run, IntelliJ envia noDebug:true al adapter y el programa corre sin pausar. Atajo: Shift+F9 = Debug. Shift+F10 = Run, NO uses ese.
5. Espera 15-25 segundos en el primer arranque. Veras en la consola los logs de hie-bios descubriendo flags y hdb compilando el modulo.
6. Cuando para en el breakpoint, abrese el panel de Debug abajo con pestañas Variables, Frames, Console.

Atajos de teclado utiles

Lo que no esperar

• HLS no funciona con GHC 9.14 todavia. El plugin Haskell LSP intentara arrancar HLS y fallara. Es esperado, no rompe el debugger. Cuando los maintainers de HLS actualicen, vuelve.
• Cada Debug recompila. Es inherente a hdb (necesita el bytecode interpreter de GHC). 15-25s por sesion.
• ${file} no se sustituye. Si lo intentas usar en entryFile esperando que IntelliJ lo expanda al fichero abierto, NO funciona. Usa la ruta absoluta o $PROJECT_DIR$/path/al/fichero.hs.

Cierre

Con esto pausas codigo Haskell en IntelliJ Ultimate, inspeccionas thunks y haces stepping. La intuicion de lazy evaluation que antes solo se ganaba leyendo libros, ahora se ve en pantalla.

El howto equivalente para Doom Emacs esta aqui: Howto Doom Emacs + hdb.