# Riferimento per la scrittura in ExpandaEVE ExpandaEVE è la forma leggibile del linguaggio EVE. È ciò che scrivi in un file di filtro `.eve`. Ogni costrutto qui viene tradotto in [CompactaEVE](page:eve/compacta) e poi compilato. Questa pagina documenta ciascun costrutto con esempi reali tratti dai file di filtro distribuiti. Per le direttive a livello di documento (`DEFINE`, `LET`, `REALM`, le istruzioni di regola) vedi [Il linguaggio EVE](page:eve/language). Questa pagina riguarda il corpo di una regola fuzzy: il pattern stesso. ## La forma di un corpo di regola Un corpo di regola fuzzy ha sempre una radice e può aggiungere un numero qualsiasi di costrutti attorno a essa. La radice è la parola stem su cui la regola è costruita. Tutto il resto la raffina: suffissi, gestione dei plurali, esclusioni, contesto e così via. ```text HEAR rule AS fuck(WHOLE) suffix(NONE OR er OR ers OR ing OR ed OR s) FLAG(pf YES) ``` Qui `fuck(WHOLE)` è la radice, `suffix(...)` aggiunge terminazioni consentite, e `FLAG(pf YES)` etichetta la categoria. I costrutti possono apparire in qualsiasi ordine che si legga in modo naturale; il traduttore riconosce ciascuno tramite la parola chiave. ## La radice e i suoi marcatori di confine La radice è l'ancoraggio di una regola. Esattamente un marcatore di radice imposta quanto strettamente la corrispondenza è delimitata alla radice: | Marcatore | Significato | |--------|---------| | `(WHOLE)` | La radice deve corrispondere come parola intera. Il candidato inizia con lo stem della radice e l'intero percorso arriva fino a un confine di parola. Scritto `[^^]` in CompactaEVE. | | `(ROOT)` | La radice è uno stem su cui suffissi e gruppi si costruiscono. Non deve essere una parola intera da sola. Scritto `[*^]` in CompactaEVE. | Usa `(WHOLE)` quando la parola nuda è essa stessa l'offesa: ```text spic(WHOLE) PLURAL ``` Usa `(ROOT)` quando attaccherai terminazioni o gruppi finali: ```text ni(ROOT) suffix(g OR ga OR gga OR gger OR gl LETTER t) PLURAL ``` !!! warning "Ogni regola fuzzy ha bisogno di un marcatore di radice" Un corpo di regola senza un marcatore `(WHOLE)` o `(ROOT)` non può compilare. Il marcatore è ciò che separa lo stem della radice dal resto del pattern. ### Il matching fuzzy è automatico Una radice fuzzy non è un test di stringa letterale. Il matcher tollera già l'evasione comune: le vocali sono intercambiabili tramite l'insieme di vocali, le lettere possono essere allungate, e i gap (vedi [GAP](#gap-and-letter)) lasciano passare i caratteri inseriti dove lo consenti. Non lo abiliti; è così che le regole fuzzy corrispondono. Per catturare una gamma più ampia di errori di ortografia deliberati, aggiungi [alias](#alias-alternate-spellings) e [skeleton](#skeleton-exact-spellings). ## suffix: terminazioni consentite `suffix(...)` elenca le terminazioni che la parola può assumere dopo la radice. Le opzioni sono separate da `OR`. È necessario solo un gruppo di suffissi, ma puoi impilarne diversi; ciascuno aggiunge un segmento opzionale in ordine. ```text bitch(WHOLE) suffix(NONE OR es OR ed OR ing OR y OR ier OR iest OR fest OR fests) ``` `NONE` significa che la terminazione è opzionale: la parola può terminare proprio alla radice. Senza un'opzione `NONE` il suffisso è richiesto. I gruppi di suffissi si compongono da sinistra a destra, quindi diversi di fila costruiscono una catena di segmenti opzionali: ```text fa(ROOT) suffix(g OR gg OR NONE) suffix(ggot OR NONE) suffix(ggie OR NONE) ``` Un'opzione di suffisso può contenere essa stessa `GAP` o `LETTER` (vedi [GAP e 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` aggiunge un ricco insieme di terminazioni plurali e di flessione in una sola parola. Si espande nella classe integrata `s` di terminazioni, quindi una regola etichettata `PLURAL` cattura anche `-s`, `-z`, `-es`, `-ing`, `-ed`, `-er`, `-y` e gli altri membri dichiarati nella funzione `s`. ```text dyke(WHOLE) PLURAL ``` `PLURAL` legge la classe chiamata `s`. Il filtro inglese distribuito la dichiara come: ```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'opzione scritta `from>to` è una terminazione di riscrittura: corrisponde a una parola che termina con `to` testando la radice con la terminazione `from` al suo posto. `y>ies` cattura una parola che termina con `ies` come se terminasse con `y`, che è il modo in cui `baby` e `babies` sono entrambi raggiunti da una radice. Vedi [Suffissi di riscrittura](page:eve/compacta#rewrite-suffixes) per i meccanismi. ## NEVER: esclusioni `NEVER(...)` elenca le frasi che non devono apparire nella riga circostante. Se una qualsiasi frase elencata è presente, la regola non si attiva, anche se il pattern corrisponde altrimenti. Questo è il modo in cui una radice aggressiva viene tenuta lontana dal catturare parole innocenti. ```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) ``` Un controllo `NEVER` è un semplice test di sottostringa contro l'intera riga, in minuscolo. Se la frase è ovunque nel messaggio, la regola viene posta in veto. ## ALIAS: grafie alternative `ALIAS(...)` aggiunge una grafia alternativa della radice. Ogni alias è una variante di radice separata che riutilizza il resto della regola (i suoi suffissi, gruppi, esclusioni). Elenca un alias per riga per coprire errori di ortografia deliberati e scambi di lettere. ```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) ``` Ogni alias qui corrisponde con lo stesso insieme di suffissi di `fuck`. Un alias può portare il proprio marcatore `(WHOLE)` o `(ROOT)`; senza uno eredita il confine della radice. Un alias può fare riferimento a una funzione, nel qual caso ogni membro di quella funzione diventa un alias: ```text ALIAS(function(selfharmverb)) kill(ROOT) ``` Un alias può anche essere una parola segmentata o un frammento a più parti; viene normalizzato allo stesso modo della radice. ## ALSO: frammenti additivi `ALSO(...)` aggiunge un frammento che può apparire ovunque dopo la radice anziché in ordine fisso. Viene usato quando una parola extra richiesta può fluttuare rispetto allo stem. ```text kill(ROOT) GAP suffix(yo OR ur OR your OR yor) suffix(self) ALSO(wrists OR wrist OR throat) ``` `ALSO` si riduce a un gruppo fluttuante che si attacca in qualsiasi posizione raggiungibile dopo la radice e i gruppi normali. Vedi [Gruppi plus](page:eve/compacta#plus-groups-floating) per come viene corrisposto un gruppo fluttuante. ## GAP e LETTER Queste abbreviazioni controllano cosa può stare tra le parti di un pattern. | Costrutto | Significato | CompactaEVE | |-----------|---------|-------------| | `GAP` | Una serie opzionale di caratteri qualsiasi (lettere o non lettere), così che spazi, punteggiatura o riempitivi inseriti siano tollerati. | `(#*)` | | `LETTERS` | Una serie opzionale di sole lettere. | `($^)` | | `LETTER` | Esattamente un carattere di materiale di parola. | `@` | `GAP` tra una radice e un suffisso permette a una frase di distribuirsi su più parole: ```text moon(ROOT) GAP suffix(cricket) PLURAL ``` Questo cattura `moon cricket`, `mooncricket` e grafie con riempitivo tra le due parti. `LETTER` corrisponde a un singolo carattere, utile all'interno di un'opzione di suffisso per consentire una posizione jolly: ```text suffix(m LETTER GAP OR NONE) ``` `LETTERS` corrisponde a una serie di sole lettere, quindi si ferma a uno spazio: ```text my(ROOT) GAP LETTERS GAP suffix(hit) ``` !!! note "Cosa conta come lettera" Il materiale di parola è una lettera ASCII o qualsiasi byte di un glifo non ASCII, quindi una serie di emoji o simboli conta anch'essa come materiale di parola per i confini e il jolly `LETTER`. Il testo ASCII semplice non è influenzato. ## OR e NONE `OR` separa le alternative all'interno di un costrutto come `suffix(...)`, `NEVER(...)`, `ALSO(...)`, `BEFORE(...)` e `AFTER(...)`, e separa i membri delle classi in una dichiarazione `LET`. Deve stare come parola intera. `NONE` è un'alternativa vuota. In un suffisso rende la terminazione opzionale; in un elenco di membri di funzione lascia che la classe contribuisca con una corrispondenza vuota: ```text LET function(quantifier) BE NONE OR some OR any OR a OR an OR the ``` ## BEFORE e AFTER: gating di contesto Questi condizionano una regola su testo altrove nella riga. Vengono usati per far attivare un termine altrimenti ampio o ambiguo solo in un contesto rivelatore. | Costrutto | Significato | CompactaEVE | |-----------|---------|-------------| | `BEFORE(...)` | Un precheck. La regola si attiva solo quando una delle frasi elencate appare nella riga circostante. | `{pre:...}` | | `AFTER(...)` | Una post condizione. Terminazioni consentite che permettono alla regola di attivarsi sulla parola stessa anche senza una frase di 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` è un semplice controllo di sottostringa contro l'intera riga, in minuscolo. Quando una regola ha un gate `BEFORE` rimane inattiva a meno che una delle frasi sia presente, o a meno che la parola soddisfi la post condizione `AFTER` da sola. `AFTER` accetta un plurale finale `s` sulle sue terminazioni. Vedi [Gating](page:eve/compacta#precheck-and-post-gating) per la regola esatta. ## SWAP: insieme di sostituzione inline `SWAP(...)` corrisponde a un qualsiasi frammento di diversi piccoli frammenti in una posizione, con controllo sui confini di parola. Viene usato dove un breve pezzo intercambiabile sta all'interno di una frase. ```text kill(ROOT) GAP SWAP(my* OR me*) suffix(self) ``` Ogni opzione può portare asterischi che liberano un confine: - Un `*` iniziale libera l'inizio (l'opzione non deve iniziare a un confine di parola). - Un `*` finale libera la fine. - Nessun asterisco, o un doppio `**` iniziale, ancora entrambi i lati a un confine di parola. Quindi `my*` corrisponde a `my` con un confine richiesto prima ma non necessariamente dopo, permettendogli di scorrere in `self`. Vedi [Swap](page:eve/compacta#swaps) per le regole di confine per intero. ## SKELETON: grafie esatte `SKELETON(...)` elenca le forme di parola esatte che la regola corrisponde anche direttamente, aggirando il matcher fuzzy. Viene usato per fissare grafie offuscate specifiche usando liste di scelta inline. ```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) ``` Uno skeleton viene espanso nell'insieme completo di parole concrete che può comporre, e qualsiasi candidato uguale a una di quelle parole corrisponde immediatamente. L'espansione prende il prodotto incrociato di ogni scelta, quindi `n[a,e,i,o,u]gg[a,e,i,o,u]r` produce `naggar`, `neggar`, `niggar` e così via per ogni coppia di vocali. ### Liste di scelta inline All'interno di uno skeleton, `[a,e,i,o,u]` è una lista di scelta inline: una posizione di carattere che può essere uno qualsiasi dei membri separati da virgola. I membri possono essere più lunghi di un carattere. Gli spazi bianchi attorno a un membro vengono rimossi. Uno skeleton può anche fare riferimento a una funzione con `&name`, che si espande nei membri di quella funzione. ```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]) ``` Il risultato è in minuscolo. Gli skeleton corrispondono alla grafia esatta, quindi sono complementari alla radice fuzzy, che gestisce le varianti più libere. ## FUNCTION: classi con nome Una funzione è una classe con nome dichiarata con `LET` (vedi [Il linguaggio EVE](page:eve/language#let-defining-a-function-named-class)). Viene referenziata con `function(name)`, e il riferimento si espande nei membri della classe. Le funzioni hanno diversi ruoli a seconda di dove appaiono. Come un intero gruppo di alternative in un corpo di regola: ```text groom(ROOT) suffix(NONE OR ing OR ed) GAP MAYBE function(declarative) GAP function(vulnerable) ``` Come un alias, dove ogni membro diventa una radice alternativa: ```text ALIAS(function(genderword)) internal GAP condom(WHOLE) ``` All'interno di un elenco `suffix`, `NEVER`, `ALSO`, `BEFORE` o `AFTER`, dove i membri si uniscono alle alternative: ```text suffix(function(article) OR box of OR a box of OR internal OR function(genderword) OR NONE) ``` ### Modificatori di funzione Un riferimento `function(...)` può portare modificatori, uniti con `+`: | Modificatore | Effetto | CompactaEVE | |----------|--------|-------------| | `ADDITIVE` | Il riferimento è un'aggiunta fluttuante alla corrispondenza anziché un requisito in ordine fisso. | avvolge come gruppo plus `[+[...]]` | | `GAP` | Il riferimento corrisponde in modo lasco, consentendo un gap dopo di esso. | aggiunge `(#*)` | ```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 ``` Ogni funzione additiva qui fluttua nella corrispondenza ovunque si adatti, quindi il soggetto, il desiderio e il quantificatore possono apparire in ordine variabile prima della radice. ## MAYBE FUNCTION: funzione opzionale `MAYBE FUNCTION(name)` rende opzionale un riferimento a una funzione: la corrispondenza ha successo che uno dei suoi membri sia presente o meno. ```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) ``` Qui `function(declarative)` (parole come `a`, `the`, `my`) può apparire o meno tra il verbo e la parola che indica la persona vulnerabile. ## FLAG: regole condizionali ed etichettatura delle categorie `FLAG(name YES)` etichetta la regola con un flag dichiarato. Quando la regola si attiva, quel flag viene impostato, che è il modo in cui il filtro riporta una categoria come autolesionismo o abuso anziché un blocco ordinario. ```text kms(WHOLE) FLAG(sh YES) ``` Il valore può essere scritto `YES`, `Y` o `TRUE` per attivo, e qualsiasi altra cosa per disattivo. Il nome del flag deve essere dichiarato con `DEFINE` (vedi [Il linguaggio EVE](page:eve/language#define-declaring-flag-ids)), altrimenti il documento non riesce a caricarsi. Sotto il cofano un flag avvolge il pattern in un gate condizionale; vedi [Wrapper di flag](page:eve/compacta#flag-wrappers). ## NOTE: commenti `NOTE(...)` allega un commento inline. Viene rimosso prima della compilazione e non influisce sul matching, quindi è un modo per annotare un pattern sul posto. I commenti su tutta la riga usano comunque un `#` iniziale. ## ALIAS con marcatori WHOLE o ROOT Un alias può terminare con `(WHOLE)` o `(ROOT)` per impostare il proprio confine, indipendentemente da quello della radice: ```text ALIAS(dike) dyke(WHOLE) ``` Senza un marcatore finale l'alias eredita il marcatore di confine della radice. ## Radici segmentate Una radice può essere scritta come diversi pezzi tra parentesi e senza per marcare parte di essa come flessibile. Quando sono presenti almeno due pezzi e almeno uno è tra parentesi, si fondono in un'unica radice con punti di ingresso alternativi. ```text re[tard] (WHOLE) suffix(NONE OR d OR ded OR ted OR t OR der OR ders OR ing OR ed OR s) ``` Il pezzo tra parentesi marca il segmento flessibile. Vedi [Radici segmentate](page:eve/compacta#segmented-roots) per sapere esattamente quali alternative vengono generate. ## Mettere tutto insieme Una regola realistica combina diversi costrutti: ```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]) ``` Questa regola ha un alias per un errore di ortografia comune, una radice con un insieme di suffissi fisso, e skeleton per le grafie in leetspeak che il matcher fuzzy potrebbe mancare. Leggi [CompactaEVE](page:eve/compacta) per vedere come ciascuno di questi si riduce e corrisponde.