# Referencia de creación de ExpandaEVE ExpandaEVE es la forma legible del lenguaje EVE. Es lo que escribes en un archivo de filtro `.eve`. Cada construcción de aquí se traduce a [CompactaEVE](page:eve/compacta) y luego se compila. Esta página documenta cada construcción con ejemplos reales extraídos de los archivos de filtro que vienen de fábrica. Para las directivas de nivel de documento (`DEFINE`, `LET`, `REALM`, las instrucciones de regla) consulta [El lenguaje EVE](page:eve/language). Esta página trata sobre el cuerpo de una regla difusa: el patrón en sí. ## La forma del cuerpo de una regla El cuerpo de una regla difusa siempre tiene una raíz y puede añadir cualquier número de construcciones a su alrededor. La raíz es la palabra tallo sobre la que se construye la regla. Todo lo demás la refina: sufijos, gestión de plurales, exclusiones, contexto, y así sucesivamente. ```text HEAR rule AS fuck(WHOLE) suffix(NONE OR er OR ers OR ing OR ed OR s) FLAG(pf YES) ``` Aquí `fuck(WHOLE)` es la raíz, `suffix(...)` añade las terminaciones permitidas y `FLAG(pf YES)` etiqueta la categoría. Las construcciones pueden aparecer en cualquier orden que se lea de forma natural; el traductor reconoce cada una por palabra clave. ## La raíz y sus marcadores de límite La raíz es el ancla de una regla. Exactamente un marcador de raíz establece con qué rigor se delimita la coincidencia en la raíz: | Marcador | Significado | |--------|---------| | `(WHOLE)` | La raíz debe coincidir como palabra completa. El candidato comienza con el tallo raíz y toda la ruta se extiende hasta un límite de palabra. Se escribe `[^^]` en CompactaEVE. | | `(ROOT)` | La raíz es un tallo sobre el que se construyen los sufijos y grupos. No necesita ser una palabra completa por sí misma. Se escribe `[*^]` en CompactaEVE. | Usa `(WHOLE)` cuando la palabra desnuda es en sí misma la infracción: ```text spic(WHOLE) PLURAL ``` Usa `(ROOT)` cuando vayas a adjuntar terminaciones o grupos finales: ```text ni(ROOT) suffix(g OR ga OR gga OR gger OR gl LETTER t) PLURAL ``` !!! warning "Cada regla difusa necesita un marcador de raíz" Un cuerpo de regla sin un marcador `(WHOLE)` o `(ROOT)` no puede compilar. El marcador es lo que separa el tallo raíz del resto del patrón. ### La coincidencia difusa es automática Una raíz difusa no es una prueba de cadena literal. El matcher ya tolera la evasión común: las vocales son intercambiables a través del conjunto de vocales, las letras pueden estirarse y los huecos (consulta [GAP](#gap-and-letter)) dejan pasar caracteres insertados donde los permitas. No lo activas; así es como coinciden las reglas difusas. Para capturar un abanico más amplio de faltas de ortografía deliberadas, añade [alias](#alias-alternate-spellings) y [skeletons](#skeleton-exact-spellings). ## suffix: terminaciones permitidas `suffix(...)` enumera las terminaciones que la palabra puede tomar después de la raíz. Los brazos se separan con `OR`. Solo se necesita un grupo de sufijo, pero puedes apilar varios; cada uno añade un segmento opcional en orden. ```text bitch(WHOLE) suffix(NONE OR es OR ed OR ing OR y OR ier OR iest OR fest OR fests) ``` `NONE` significa que la terminación es opcional: la palabra puede terminar justo en la raíz. Sin un brazo `NONE` el sufijo es obligatorio. Los grupos de sufijo se componen de izquierda a derecha, así que varios seguidos construyen una cadena de segmentos opcionales: ```text fa(ROOT) suffix(g OR gg OR NONE) suffix(ggot OR NONE) suffix(ggie OR NONE) ``` Un brazo de sufijo puede contener él mismo `GAP` o `LETTER` (consulta [GAP y LETTER](#gap-and-letter)): ```text suffix(g OR ga OR gga OR gger OR gl LETTER t) ``` ```text suffix(my GAP OR NONE) ``` ### PLURAL `PLURAL` añade un rico conjunto de terminaciones de plural e inflexión en una palabra. Se expande a la clase integrada `s` de terminaciones, así que una regla etiquetada con `PLURAL` también captura `-s`, `-z`, `-es`, `-ing`, `-ed`, `-er`, `-y` y los demás miembros declarados en la función `s`. ```text dyke(WHOLE) PLURAL ``` `PLURAL` lee la clase llamada `s`. El filtro inglés que viene de fábrica la declara como: ```text LET function(s) BE s OR z OR es OR ez OR ies OR iez OR y>ies OR y>iez OR ing OR ings OR ed OR er OR ers OR y OR ys ``` Un brazo escrito `from>to` es una terminación de reescritura: coincide con una palabra que termina en `to` probando la raíz con la terminación `from` en su lugar. `y>ies` captura una palabra que termina en `ies` como si terminara en `y`, que es como `baby` y `babies` se alcanzan ambos desde una raíz. Consulta [Sufijos de reescritura](page:eve/compacta#rewrite-suffixes) para conocer los mecanismos. ## NEVER: exclusiones `NEVER(...)` enumera frases que no deben aparecer en la línea circundante. Si alguna frase listada está presente, la regla no se dispara, aunque el patrón coincida por lo demás. Así es como se evita que una raíz agresiva capture palabras inocentes. ```text wop(WHOLE) PLURAL NEVER(doowop OR doo wop OR doowap OR doo wap OR dowap OR do wap OR do wop) ``` ```text gook(WHOLE) PLURAL NEVER(600k OR 900k OR 60ok OR 90ok OR 6ook OR 9ook OR 600ks OR 900ks) ``` Una comprobación `NEVER` es una prueba de subcadena simple contra toda la línea, en minúsculas. Si la frase está en cualquier lugar del mensaje, la regla se veta. ## ALIAS: grafías alternativas `ALIAS(...)` añade una grafía alternativa de la raíz. Cada alias es una variante de raíz separada que reutiliza el resto de la regla (sus sufijos, grupos, exclusiones). Enumera un alias por línea para cubrir faltas de ortografía deliberadas e intercambios de letras. ```text ALIAS(phuck) ALIAS(fuk) ALIAS(fukk) ALIAS(fucc) ALIAS(fck) ALIAS(fk) fuck(WHOLE) suffix(NONE OR er OR ers OR ing OR ed OR s) ``` Cada alias aquí coincide con el mismo conjunto de sufijos que `fuck`. Un alias puede llevar su propio marcador `(WHOLE)` o `(ROOT)`; sin uno, hereda el límite de la raíz. Un alias puede referenciar una función, en cuyo caso cada miembro de esa función se convierte en un alias: ```text ALIAS(function(selfharmverb)) kill(ROOT) ``` Un alias también puede ser una palabra segmentada o un fragmento de varias partes; se normaliza de la misma forma que la raíz. ## ALSO: fragmentos aditivos `ALSO(...)` añade un fragmento que puede aparecer en cualquier lugar después de la raíz en lugar de en un orden fijo. Se usa cuando una palabra extra requerida puede flotar respecto al tallo. ```text kill(ROOT) GAP suffix(yo OR ur OR your OR yor) suffix(self) ALSO(wrists OR wrist OR throat) ``` `ALSO` se reduce a un grupo flotante que se une en cualquier posición alcanzable después de la raíz y los grupos normales. Consulta [Grupos plus](page:eve/compacta#plus-groups-floating) para ver cómo coincide un grupo flotante. ## GAP y LETTER Estos atajos controlan lo que puede situarse entre las partes de un patrón. | Construcción | Significado | CompactaEVE | |-----------|---------|-------------| | `GAP` | Una serie opcional de caracteres cualesquiera (letras o no letras), así que se toleran espacios, puntuación o relleno insertados. | `(#*)` | | `LETTERS` | Una serie opcional de letras únicamente. | `($^)` | | `LETTER` | Exactamente un carácter de material de palabra. | `@` | `GAP` entre una raíz y un sufijo permite que una frase se reparta entre palabras: ```text moon(ROOT) GAP suffix(cricket) PLURAL ``` Esto captura `moon cricket`, `mooncricket` y grafías con relleno entre las dos partes. `LETTER` coincide con un solo carácter, útil dentro de un brazo de sufijo para permitir una posición comodín: ```text suffix(m LETTER GAP OR NONE) ``` `LETTERS` coincide con una serie de letras únicamente, así que se detiene en un espacio: ```text my(ROOT) GAP LETTERS GAP suffix(hit) ``` !!! note "Qué cuenta como letra" El material de palabra es una letra ASCII o cualquier byte de un glifo no ASCII, así que una serie de emojis o símbolos también cuenta como material de palabra para los límites y el comodín `LETTER`. El texto ASCII plano no se ve afectado. ## OR y NONE `OR` separa alternativas dentro de una construcción como `suffix(...)`, `NEVER(...)`, `ALSO(...)`, `BEFORE(...)` y `AFTER(...)`, y separa los miembros de clase en una declaración `LET`. Debe aparecer como una palabra completa. `NONE` es una alternativa vacía. En un sufijo hace opcional la terminación; en una lista de miembros de función deja que la clase contribuya con una coincidencia vacía: ```text LET function(quantifier) BE NONE OR some OR any OR a OR an OR the ``` ## BEFORE y AFTER: regulación por contexto Estos regulan una regla según el texto en otro lugar de la línea. Se usan para hacer que un término por lo demás amplio o ambiguo se dispare solo en un contexto revelador. | Construcción | Significado | CompactaEVE | |-----------|---------|-------------| | `BEFORE(...)` | Un precheck. La regla solo se activa cuando una de las frases listadas aparece en la línea circundante. | `{pre:...}` | | `AFTER(...)` | Una condición posterior. Terminaciones permitidas que dejan que la regla se dispare sobre la palabra en sí incluso sin una frase de precheck presente. | `{post:...}` | ```text BEFORE(function(seeking)) cp AFTER(mega OR pack OR packs OR nz OR db OR dropbox OR folder OR vids OR pics) (WHOLE) ``` Una frase `BEFORE` es una comprobación de subcadena simple contra toda la línea, en minúsculas. Cuando una regla tiene una puerta `BEFORE` permanece inerte a menos que una de las frases esté presente, o a menos que la palabra satisfaga la condición posterior `AFTER` por sí sola. `AFTER` acepta un plural final `s` en sus terminaciones. Consulta [Regulación](page:eve/compacta#precheck-and-post-gating) para conocer la regla exacta. ## SWAP: conjunto de sustitución en línea `SWAP(...)` coincide con cualquiera de varios fragmentos pequeños en una posición, con control sobre los límites de palabra. Se usa donde una pieza corta intercambiable se sitúa dentro de una frase. ```text kill(ROOT) GAP SWAP(my* OR me*) suffix(self) ``` Cada brazo puede llevar asteriscos que liberan un límite: - Un `*` inicial libera el inicio (el brazo no necesita empezar en un límite de palabra). - Un `*` final libera el fin. - Sin asterisco, o un `**` inicial doble, ancla ambos lados a un límite de palabra. Así, `my*` coincide con `my` con un límite requerido antes de él pero no necesariamente después, dejándolo fluir hacia `self`. Consulta [Swaps](page:eve/compacta#swaps) para las reglas de límite completas. ## SKELETON: grafías exactas `SKELETON(...)` enumera formas de palabra exactas que la regla también coincide directamente, saltándose el matcher difuso. Se usa para fijar grafías ofuscadas específicas usando listas de opciones en línea. ```text ni(ROOT) suffix(g OR ga OR gga OR gger OR gl LETTER t) PLURAL NEVER(snigger OR sniggers OR sniggered) SKELETON(n[a,e,i,o,u]gg[a,e,i,o,u]r OR n[a,e,i,o,u]gg[a,e,i,o,u]h) ``` Un skeleton se expande al conjunto completo de palabras concretas que puede deletrear, y cualquier candidato igual a una de esas palabras coincide inmediatamente. La expansión toma el producto cruzado de cada opción, así que `n[a,e,i,o,u]gg[a,e,i,o,u]r` produce `naggar`, `neggar`, `niggar`, y así sucesivamente para cada par de vocales. ### Listas de opciones en línea Dentro de un skeleton, `[a,e,i,o,u]` es una lista de opciones en línea: una posición de carácter que puede ser cualquiera de los miembros separados por comas. Los miembros pueden tener más de un carácter. Los espacios en blanco alrededor de un miembro se recortan. Un skeleton también puede referenciar una función con `&name`, que se expande a los miembros de esa función. ```text SKELETON(r[e,i]t[a,e,i]rd) ``` ```text SKELETON(m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t OR m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t[a,e,i,o,u]) ``` El resultado se pasa a minúsculas. Los skeletons coinciden con la grafía exacta, así que son complementarios a la raíz difusa, que gestiona las variantes más sueltas. ## FUNCTION: clases con nombre Una función es una clase con nombre declarada con `LET` (consulta [El lenguaje EVE](page:eve/language#let-defining-a-function-named-class)). Se referencia con `function(name)`, y la referencia se expande a los miembros de la clase. Las funciones tienen varios roles según dónde aparezcan. Como grupo completo de alternativas en el cuerpo de una regla: ```text groom(ROOT) suffix(NONE OR ing OR ed) GAP MAYBE function(declarative) GAP function(vulnerable) ``` Como alias, donde cada miembro se convierte en una raíz alternativa: ```text ALIAS(function(genderword)) internal GAP condom(WHOLE) ``` Dentro de una lista `suffix`, `NEVER`, `ALSO`, `BEFORE` o `AFTER`, donde los miembros se unen a las alternativas: ```text suffix(function(article) OR box of OR a box of OR internal OR function(genderword) OR NONE) ``` ### Modificadores de función Una referencia `function(...)` puede llevar modificadores, unidos con `+`: | Modificador | Efecto | CompactaEVE | |----------|--------|-------------| | `ADDITIVE` | La referencia es una adición flotante a la coincidencia en lugar de un requisito de orden fijo. | se envuelve como un grupo plus `[+[...]]` | | `GAP` | La referencia coincide de forma suelta, permitiendo un hueco después de ella. | añade `(#*)` | ```text function(subject + ADDITIVE + GAP) function(desire + ADDITIVE + GAP) function(quantifier + ADDITIVE + GAP) rap(ROOT) suffix(e OR ist OR ed OR ing OR eable OR able) PLURAL ``` Cada función aditiva aquí flota hacia la coincidencia dondequiera que encaje, así que las palabras de sujeto, deseo y cuantificador pueden aparecer en orden variable antes de la raíz. ## MAYBE FUNCTION: función opcional `MAYBE FUNCTION(name)` hace opcional una referencia de función: la coincidencia tiene éxito esté o no presente uno de sus miembros. ```text rap(ROOT) suffix(NONE OR e OR es OR ed OR ing OR eing OR in OR ist OR ists) GAP MAYBE function(declarative) GAP function(vulnerable) ``` Aquí `function(declarative)` (palabras como `a`, `the`, `my`) puede aparecer o no entre el verbo y la palabra de persona vulnerable. ## FLAG: reglas condicionales y etiquetado de categoría `FLAG(name YES)` etiqueta la regla con una flag declarada. Cuando la regla se dispara, esa flag se establece, que es como el filtro reporta una categoría como autolesión o abuso en lugar de un bloqueo ordinario. ```text kms(WHOLE) FLAG(sh YES) ``` El valor puede escribirse `YES`, `Y` o `TRUE` para activado, y cualquier otra cosa para desactivado. El nombre de la flag debe declararse con `DEFINE` (consulta [El lenguaje EVE](page:eve/language#define-declaring-flag-ids)), o el documento no se carga. Por debajo, una flag envuelve el patrón en una puerta condicional; consulta [Envoltorios de flag](page:eve/compacta#flag-wrappers). ## NOTE: comentarios `NOTE(...)` adjunta un comentario en línea. Se elimina antes de la compilación y no afecta a la coincidencia, así que es una forma de anotar un patrón en el sitio. Los comentarios de línea completa siguen usando un `#` inicial. ## ALIAS con marcadores WHOLE o ROOT Un alias puede terminar en `(WHOLE)` o `(ROOT)` para establecer su propio límite, independiente del de la raíz: ```text ALIAS(dike) dyke(WHOLE) ``` Sin un marcador final, el alias hereda el marcador de límite de la raíz. ## Raíces segmentadas Una raíz puede escribirse como varias piezas entre corchetes y desnudas para marcar parte de ella como flexible. Cuando hay al menos dos piezas presentes y al menos una está entre corchetes, se pliegan en una sola raíz con puntos de entrada alternativos. ```text re[tard] (WHOLE) suffix(NONE OR d OR ded OR ted OR t OR der OR ders OR ing OR ed OR s) ``` La pieza entre corchetes marca el segmento flexible. Consulta [Raíces segmentadas](page:eve/compacta#segmented-roots) para saber exactamente qué alternativas se generan. ## Poniéndolo todo junto Una regla realista combina varias construcciones: ```text HEAR rule AS ALIAS(masterb) masturb(ROOT) suffix(ate OR ating OR ation OR ated OR ates OR at) SKELETON(m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t OR m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t[a,e,i,o,u]) ``` Esta regla tiene un alias para una falta de ortografía común, una raíz con un conjunto de sufijos fijo y skeletons para las grafías en leetspeak que el matcher difuso podría pasar por alto. Lee [CompactaEVE](page:eve/compacta) para ver cómo se reduce y coincide cada una de estas.