Visitor: operaciones nuevas sobre un árbol

  • Lección 27 de 32
  • 12 min
  • Intermedio
  • 12 pasos

Un documento guardado como árbol de nodos y operaciones que no paran de llegar: contar palabras, exportar a Markdown, revisar errores. Vas a sacar cada operación a un visitor y ver qué ganas y qué pagas.

Clases de nodo a editar por operación nueva
0
Visitors a editar por tipo de nodo nuevo
2
DocDoc · 6ESLintvisit()wordCount(n)DocHeadingHeading ·1IdentifiertotalheadingHeadingParagraphParagraph· 5LiteralaparagraphParagraphImageImage · 0CallExpressionbimageImageWordCountToMarkdowntu reglavisit_NameWordCountDocVisitorinterfaceDocVisitorWordCountWordCountToMarkdownToMarkdownTableTabledoc pide wordCount()2 operaciones por claseHeading hoyclass Heading {constructor(public text: string) {}▸wordCount() { return words(this.text); }▸toMarkdown() { return `# ${this.text}`; }}3 clases a editarDónde hay que tocarHeading+ lint()Paragraph+ lint()Image+ lint()un método por tipouna operaciónUn método por tipointerface DocVisitor<R> {▸heading(n: Heading): R;paragraph(n: Paragraph): R;image(n: Image): R;}interface DocNode {▸accept<R>(v: DocVisitor<R>): R;}h.accept(v)v.heading(this)El nodo redirigeclass Heading implements DocNode {constructor(public text: string) {}accept<R>(v: DocVisitor<R>): R {▸return v.heading(this);}}1 + 5 + 0 = 6El visitor de conteoconst words = (s: string) =>s.split(/\s+/).filter(Boolean).length;const wordCount: DocVisitor<number> = {heading: (n) => words(n.text),paragraph: (n) => words(n.text),image: () => 0,};visitor nuevonodos sin cambiosUn visitor nuevo+const toMarkdown: DocVisitor<string> = {+heading: (n) => `# ${n.text}`,+paragraph: (n) => n.text,+image: (n) => `![${n.alt}](img.png)`,+};+doc.map((n) => n.accept(toMarkdown));tipo nuevo: Table+ table(n)El contrato creceinterface DocVisitor<R> {heading(n: Heading): R;paragraph(n: Paragraph): R;image(n: Image): R;+table(n: Table): R;}▸// WordCount y ToMarkdown no compilanIdentifier(node)recorre el ASTUna regla de ESLintcreate(context) {return {Identifier(node) { … },"FunctionExpression:exit"(node) { … },};},imprime cada nombredespacha por claseast.NodeVisitorimport astclass Names(ast.NodeVisitor):def visit_Name(self, node):print(node.id)▸self.generic_visit(node)Names().visit(ast.parse("total = a + b"))switch (n.kind)Union + switchfunction wordCount(n: DocNode): number {switch (n.kind) {case "heading": return words(n.text);case "paragraph": return words(n.text);case "image": return 0;▸default: return n satisfies never;}}¿qué crece más?Cuándo no usarlotipos que cambianeditas cada visitor1 o 2 operacionesun método bastaárbol chicoun switch se lee mejoruna operación = un visitorVisitor en una tablaproblemacada operación en cada clasesoluciónun visitor por operaciónacceptredirige al método del tipooperación nueva0 clases de nodo a editartipo nuevoeditas todos los visitors
  • petición
  • respuesta

Paso 1 de 12

Problema

Cada operación vive en cada clase

Un editor guarda un documento como un árbol: un Heading («Patrones»), un Paragraph y un Image («diagrama»). Para contar palabras, Doc le pide wordCount() a cada nodo y suma lo que responden.

Cada clase trae su wordCount() y su toMarkdown(). Funciona, pero cada operación está repartida entre todas las clases del árbol: para leer cómo se cuentan las palabras, abres tres archivos.

Paso 2 de 12

Problema

Llega una tercera operación: lint

Ahora quieres revisar el documento: avisar si un título está vacío o si una imagen no tiene texto alternativo. Es una operación más, lint().

Hay que abrir las tres clases y agregar un método en cada una. Los tipos de nodo casi no cambian, pero las operaciones siguen llegando, y cada una te obliga a tocarlos todos.

Qué cambió

  • lint()
  • Heading, Paragraph e Image

Paso 3 de 12

Concepto

Una operación, un objeto

La idea de Visitor: sacar cada operación de los nodos y ponerla en un objeto aparte, el visitor. Ese objeto tiene un método por tipo de nodo: heading(), paragraph() e image().

El contrato es DocVisitor<R>, donde R es lo que devuelve la operación: un número para contar palabras, un texto para Markdown. WordCount lo implementa. A los nodos solo les queda un método: accept(v).

Qué cambió

  • interface DocVisitor<R>
  • DocNode.accept(v)

Paso 4 de 12

Técnica

Dos llamadas eligen el método

Doc llama h.accept(v) sin saber qué es h. Dentro de Heading, accept hace una sola cosa: v.heading(this). El nodo conoce su propio tipo, así que elige el método correcto del visitor.

Son dos llamadas: la primera elige qué nodo (el objeto que recibe accept) y la segunda elige qué operación (el visitor que llegó). A eso se le llama double dispatch.

Paso 5 de 12

Solución

WordCount recorre el documento

wordCount es un objeto con tres funciones. Doc le pasa el mismo visitor a cada nodo, y cada nodo responde con el método de su tipo.

Heading devuelve 1, Paragraph («Un visitor separa la operación») devuelve 5 e Image devuelve 0. Doc suma 1 + 5 + 0 = 6. Toda la lógica de contar está en un solo lugar.

Paso 6 de 12

Solución

Operación nueva, cero clases tocadas

Hace falta exportar a Markdown. Con Visitor es un objeto nuevo, toMarkdown, con los mismos tres métodos. Se lo pasas a accept igual que antes.

Heading, Paragraph e Image no cambian. Sale # Patrones, el párrafo tal cual y ![diagrama](img.png). El lint del paso 2 sería un tercer visitor, igual de aislado.

Qué cambió

  • toMarkdown

Paso 7 de 12

Compromiso

El precio: un tipo de nodo nuevo

Ahora el documento admite tablas. Nace Table, y DocVisitor necesita table(n). Todos los visitors que existen dejan de compilar hasta que lo implementen: WordCount y ToMarkdown, 2 en este ejemplo.

Visitor abarata las operaciones nuevas y encarece los tipos nuevos. La documentación de Java lo advierte sobre su ElementVisitor: puede ganar métodos cuando el lenguaje sume construcciones, y recomienda extender sus visitors abstractos en vez de implementar la interfaz directamente.

Qué cambió

  • Table
  • WordCount y ToMarkdown

Paso 8 de 12

Técnica

Una regla de ESLint es un visitor

Si escribes una regla de ESLint, ya usas Visitor. create(context) devuelve un objeto cuyas claves son tipos de nodo o selectores, como Identifier. ESLint recorre el AST y llama esa función en cada nodo que coincide.

Con :exit, como en "FunctionExpression:exit", la llamada llega al subir por el árbol en vez de al bajar. Los plugins de Babel funcionan igual: un objeto con métodos por tipo de nodo, que reciben un path con el nodo y su padre.

Paso 9 de 12

Técnica

Recorrer y despachar son dos cosas

Un error común es creer que Visitor significa «recorrer un árbol». En ast.NodeVisitor de Python, visit(node) despacha: busca visit_<Clase>, aquí visit_Name, y si no existe usa generic_visit, que recorre los hijos.

Si escribes tu propio visit_Name y quieres seguir bajando, tienes que llamar self.generic_visit(node). Con total = a + b imprime total, a y b. Para modificar nodos en vez de leerlos existe NodeTransformer.

Paso 10 de 12

Técnica

En TypeScript, a veces basta un switch

Visitor tampoco exige métodos accept. Si cada nodo tiene un campo kind ("heading", "paragraph" o "image") y DocNode es la unión de los tres, una función con switch (n.kind) hace el despacho, como el objeto por tipo de nodo de ESLint.

La línea default es la clave: si mañana sumas Table a DocNode y olvidas su case, n satisfies never no compila. Tienes el mismo aviso que con DocVisitor, con menos ceremonia.

Paso 11 de 12

Compromiso

Cuándo Visitor sobra

Si los tipos de nodo cambian seguido, cada tipo nuevo te obliga a editar todos los visitors. Si solo tienes una o dos operaciones, un método en cada clase es más fácil de seguir. Y con un árbol chico, un switch se lee de un vistazo.

Además, el visitor necesita leer los datos de cada nodo (n.text, n.alt), así que los nodos dejan de esconder sus campos. Y el double dispatch cuesta seguirlo con el depurador las primeras veces.

Paso 12 de 12

Resumen

Operaciones afuera, tipos quietos

Cuando un árbol tiene tipos de nodo estables y operaciones que no paran de llegar, saca cada operación a un visitor con un método por tipo. Cada nodo solo tiene accept, que llama al método de su tipo.

Una operación nueva es un visitor nuevo, sin tocar los nodos. Un tipo nuevo te obliga a editar todos los visitors. Si los tipos cambian seguido, no lo uses.

Aprenderás

  • Reconocer el problema: cada operación nueva obliga a editar todas las clases de nodo.
  • Escribir un visitor con un método por tipo de nodo y un `accept` en cada nodo.
  • Agregar una operación nueva sin tocar las clases del árbol.
  • Reconocer el patrón en una regla de ESLint y en `ast.NodeVisitor` de Python.
  • Saber cuándo un `switch` sobre `kind` es mejor opción.